XQA
Back to Git & Dev Tools
2026-02-036 min read

Tracking files with Git LFS (Git & Dev Tools)

Learn Tracking files with Git LFS (Git & Dev Tools) step by step with clear examples and exercises.

Title: Mastering Large File Management with Git LFS (Git & Dev Tools)

Tracking large files with Git can be a challenge due to their size and the time it takes to push or pull them. This is where Git Large File Storage (LFS) comes into play, making it easier for developers to manage large binary files such as images, audio files, and videos in their Git repositories. In this lesson, we will explore how to install, configure, and use Git LFS effectively.

Why This Matters

Git LFS plays a crucial role in managing large files within Git repositories by reducing the size of large files that are stored in Git, making it faster to push and pull changes, and saving storage space on remote servers. It is essential for developers working with projects containing large binary files, as it ensures efficient collaboration and version control.

Benefits of Using Git LFS:

  • Reduced repository size: By storing only pointers to large files in the Git repository, you can significantly reduce its overall size.
  • Faster push/pull operations: With smaller repositories, pushing and pulling changes becomes much quicker.
  • Improved collaboration: Git LFS allows multiple developers to work on a project with large binary files without running into issues caused by slow file transfers or repository bloat.

Prerequisites

To follow this lesson, you should have a basic understanding of:

  • Git (version control system)
  • Command Line Interface (CLI)
  • Familiarity with GitHub or another Git hosting service

Additional Prerequisites:

  • Basic understanding of file permissions and ownership on your operating system
  • Knowledge of how to navigate the file system using commands like cd, ls, and touch

Core Concept

Git LFS is an extension that handles large files by replacing large files with text pointers inside Git, and then uploads the file content to a remote server. This way, only the text pointer is stored in the Git repository, significantly reducing its size. When someone pulls the repository, Git LFS downloads the actual large files from the remote server.

Installing Git LFS

To install Git LFS, follow these steps:

  1. Install Git LFS on your machine using the following command:
curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.sh | bash
  1. Initialize Git LFS in your repository with this command:
git lfs install
  1. Configure Git LFS to track specific file types by adding them to the .gitattributes file in your repository's root directory. For example, to track all .jpg and .png files, add this line:
*.jpg filter=lfs diff=lfs merge=lfs -text
*.png filter=lfs diff=lfs merge=lfs -text
  1. Commit the .gitattributes file to initialize Git LFS for your repository.

Using Git LFS

Once you have Git LFS installed and configured, you can start using it with these commands:

  • To add a large file to the Git repository:
git add file.jpg
git commit -m "Adding large image"
  • To push the large files to the remote server:
git lfs push origin master
  • To pull large files from the remote server:
git checkout <branch>
git lfs pull origin master

Worked Example

Let's walk through a simple example of using Git LFS to manage a large image file.

  1. Create a new repository on GitHub and clone it locally:
git clone https://github.com/yourusername/my-repo.git
cd my-repo
  1. Add an image file larger than 100MB to the repository:
touch large_image.jpg
echo "This is a large image" > large_image.jpg
git add large_image.jpg
git commit -m "Adding large image"
  1. Initialize Git LFS and configure it to track *.jpg files:
git lfs install
echo *.jpg filter=lfs diff=lfs merge=lfs -text > .gitattributes
git add .gitattributes
git commit -m "Add Git LFS configuration for JPG files"
  1. Push the changes to GitHub:
git push origin master
  1. Check the repository on GitHub to see that only the .gitattributes file has been pushed, not the large image file.
  2. Pull the repository back to your local machine and check that the large image file is downloaded:
git pull origin master
ls large_image.jpg

Common Mistakes

  • Not initializing Git LFS in the repository: Make sure you run git lfs install in your repository to initialize Git LFS.
  • Forgetting to add file types to .gitattributes: Don't forget to add the file types you want to track with Git LFS to the .gitattributes file.
  • Not committing and pushing after adding files with Git LFS: Remember to commit and push changes after adding large files with Git LFS, as only the text pointer is stored in the Git repository.

Common Mistakes (Continued)

  • Ignoring errors during installation or usage: If you encounter any errors during installation or while using Git LFS, ensure that you have followed the instructions correctly and consult relevant documentation or seek help from online resources.
  • Not properly configuring Git LFS for specific projects: Make sure to configure Git LFS for each project separately by adding the appropriate file types to the .gitattributes file in the project's root directory.

Practice Questions

  1. What command initializes Git LFS in a repository?
  2. How do you configure Git LFS to track specific file types?
  3. What happens when you push changes containing large files without using Git LFS?
  4. Explain the process of downloading large files from a remote server using Git LFS.
  5. Why is it important to use Git LFS for projects with large binary files?
  6. What are some common mistakes developers might make when working with Git LFS, and how can they avoid them?
  7. How does Git LFS handle file permissions and ownership during the upload and download process?
  8. Can Git LFS be used to manage large directories containing multiple files? If so, how?
  9. Are there any limitations or best practices regarding the size of files that Git LFS can handle?
  10. How does Git LFS affect the performance of push/pull operations in a repository with both small and large files?

FAQ

Q: Can I use Git LFS with other version control systems besides Git?

A: No, Git LFS is specifically designed for use with Git repositories.

Q: How do I handle large directories with Git LFS?

A: You can add individual files or directories to Git LFS by adding them to the .gitattributes file. To handle entire directories, you can either add all files within a directory using wildcard characters (e.g., my_directory/**/* lfs) or use a script to recursively add each file individually.**

Q: Is there a limit to the size of files that Git LFS can handle?

A: There is no hard limit on the size of files that Git LFS can handle, but it's recommended to keep large files below 2GB for optimal performance. If you encounter issues with larger files, consider compressing them before adding them to your repository or using a different solution designed for handling extremely large files.

Q: How does Git LFS affect file permissions and ownership during the upload and download process?

A: By default, Git LFS preserves the original file permissions and ownership when uploading and downloading files. However, if you encounter issues with incorrect permissions or ownership, you can configure Git LFS to handle them appropriately using the core.autocrlf, core.filemode, and user.name/user.email settings in your Git configuration file (.gitconfig).

Q: Can I use Git LFS with GitHub's free plan?

A: Yes, you can use Git LFS with GitHub's free plan, but there is a limit of 1GB of storage per user for large files. If you need more storage, consider upgrading to a paid plan or using an alternative hosting service that supports Git LFS.

Tracking files with Git LFS (Git & Dev Tools) | Git & Dev Tools | XQA Learn