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 bifurcar y fusionar código. Sin embargo, tiene un problema de rendimiento con archivos binarios grandes. Git Large File Storage (LFS) se desarrolló para abordar este problema.

El problema de los archivos grandes 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 empresas 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 pueden ser gigabytes o terabytes. Git tiene dificultades para mantener estos archivos grandes.

Para comprender el problema, debemos observar cómo Git realiza un seguimiento de los archivos. Siempre que hay una confirmación, Git crea un nodo de objeto con un puntero a su padre o varios padres. El modelo de datos de Git se conoce como gráfico acíclico dirigido (DAG). El modelo DAG asegura que la relación padre-hijo nunca pueda formar ciclos.

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

$ git log --en línea
2beb263 Confirmación C: imagen agregada1.jpeg
866178e Confirmación B: agregar b.TXT
d48dd8b Confirmación A: agregar un.TXT

En el compromiso A y B, agregamos el archivo de texto a.txt yb.TXT. Luego, en Commit C, agregamos un archivo de imagen llamado image1.jpeg. Podemos visualizar el DAG de la siguiente manera:

Comprometerse C Comprometerse B Comprometerse A
2beb263 -> 866178e -> d48dd8b

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

$ git archivo-gato -p 2beb263
árbol 7cc17ba5b041fb227b9ab5534d81bd836183a4e3
padre 866178e37df64d9f19fa77c00d5ba9d3d4fc68f5
autor Zak H 1513259427-0800
cometer Zak H 1513259427-0800
Confirmación C: imagen agregada1.jpeg

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

$ git archivo-gato -p 7cc17ba
100644 blob e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 a.TXT
100644 blob e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 b.TXT
100644 blob a44a66f9e06a8faf324d3ff3e11c9fa6966bfb56 image1.jpeg

Podemos comprobar el tamaño de la mancha de la imagen:

$ git archivo-gato -s a44a66f9e
871680

Git realiza un seguimiento de los cambios en esta estructura de árbol. Hagamos una modificación a la imagen1.jpeg y verifique el historial:

$ git log --en línea
2e257db Commit D: imagen modificada1.jpeg
2beb263 Confirmación C: imagen agregada1.jpeg
866178e Confirmación B: agregar b.TXT
d48dd8b Confirmación A: agregar un.TXT

Si comprobamos el objeto Commit D (2e257db):

$ git archivo-gato -p 2e257db
árbol 2405fad67610acf0f57b87af36f535c1f4f9ed0d
padre 2beb263523725e1e8f9d96083140a4a5cd30b651
autor Zak H 1513272250-0800
cometer Zak H 1513272250-0800
Confirmación D: imagen modificada1.jpeg

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

$ git archivo-gato -p 2405fad
100644 blob e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 a.TXT
100644 blob e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 b.TXT
100644 blob cb4a0b67280a92412a81c60df36a15150e713095 image1.jpeg

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

$ git cat-file -s cb4a0b6
1063696

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

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 almacena las diferencias y usa compresión para el almacenamiento. Pero para los cambios de archivos binarios, Git tiene que almacenar archivos completos en los 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 mancha.

Pensemos en un ejemplo en el que hacemos varios cambios en un archivo de imagen de 100 MB.

Cada vez que cambiamos el archivo, Git tiene que crear un blob de 100 MB. Entonces, solo después de 3 confirmaciones, 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, descargará todo el repositorio en su instancia local y trabajará mucho con las ramas. Entonces, las manchas grandes se convierten en un cuello de botella de rendimiento.

Git LFS resuelve el problema reemplazando los blobs con archivos de puntero livianos (PF) y creando un mecanismo para almacenar los blobs en otro lugar.

Localmente, Git almacena los blobs en la caché de Git LFS y, de forma remota, los almacenará en la tienda de Git LFS en GitHub o BitBucket.

PF1 -> Blob1
PF2 -> Blob2
PF3 -> Blob3

Ahora, cuando se trata del repositorio de Git, los archivos PF ligeros se utilizarán para las operaciones de rutina. Las manchas se recuperarán solo cuando sea necesario. Por ejemplo, si comprueba Commit C, Git LFS buscará el puntero PF3 y descargará Blob3. Entonces, el repositorio de trabajo será más ágil y el rendimiento será mejor. No tienes que preocuparte por los archivos de puntero. Git LFS los gestionará detrás de escena.

Instalación y ejecución de 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 tienes que instalar LFS y decirle qué archivos rastrear.

Puede instalar Git LFS usando los siguientes comandos:

$ 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 install

Una vez que haya instalado Git LFS, puede rastrear los archivos que desee:

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

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

$ gato .gitattributes
*.jpeg filter = lfs diff = lfs merge = lfs -text

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

$ git lfs pista
Listado de patrones seguidos
*.jpeg.gitattributes)

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

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

Para las operaciones generales de Git, no tiene que preocuparse por 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 temas más avanzados, consulte los siguientes recursos:

Mover el repositorio de Git LFS entre hosts
Eliminación de archivos locales de Git LFS
Eliminando archivos remotos de Git LFS del servidor
Sitio web de Git LFS
Documentación de Git LFS

Referencias:

git-lfs.github.com: repositorio de GitHub
github.com / git-lfs / git-lfs / tree / master / docs: Documentación de GitHub para Git LFS
atlassian.com / git / tutorials / git-lfs: Tutoriales de Atlassian
YouTube.com: ¿Qué es Git LFS?
YouTube.com: Seguimiento de archivos enormes con Git LFS por Tim Pettersen, Atlassian
YouTube.com: Administrar archivos enormes en el almacenamiento correcto con Git LFS, YouTube
YouTube.com: Almacenamiento de archivos grandes de Git: cómo trabajar con archivos grandes, YouTube
askubuntu.com / questions / 799341: cómo-instalar-git-lfs-on-ubuntu-16-04
github.com / git-lfs / git-lfs / blob / master / INSTALACIÓN.md: Guía de instalación