We are still cooking the magic in the way!
Git & GitHub
Cloning Repositories
Cloning Repositories
Cloning is the process of creating a local copy of a remote repository. In this lesson, we'll explore how to clone repositories, understand different cloning options, and learn about various cloning strategies.
What is Cloning?
Cloning creates a complete copy of a remote repository on your local machine, including all files, branches, commits, and history. It's the most common way to start working with an existing project.
Key Concept: When you clone, Git automatically sets up the remote repository as "origin" and creates a local copy of the default branch, giving you a fully functional local repository.
Basic Clone Command
The basic syntax for cloning:
# Clone a repository
git clone <repository-url>
# Examples:
# HTTPS
git clone https://github.com/user/repo.git
# SSH
git clone git@github.com:user/repo.git
# The repository will be cloned into a folder named "repo"
Clone Into a Specific Directory
You can specify a custom directory name:
# Clone into a specific directory
git clone <repository-url> <directory-name>
# Example:
git clone https://github.com/user/repo.git my-project
# Now the repository is in "my-project" folder
cd my-project
Tip: Use a custom directory name when the repository name is generic or when you want to organize projects with a specific naming convention.
What Happens During Clone
When you clone a repository, Git:
1. Creates a new directory with the repository name
2. Initializes a .git directory inside it
3. Downloads all repository data (commits, files, branches)
4. Creates a remote called "origin" pointing to the source
5. Checks out the default branch (usually main or master)
6. Sets up tracking between local and remote branches
# After cloning, you can verify:
cd repo
git remote -v
# origin https://github.com/user/repo.git (fetch)
# origin https://github.com/user/repo.git (push)
git branch -a
# * main
# remotes/origin/HEAD -> origin/main
# remotes/origin/main
# remotes/origin/develop
Shallow Clones
Shallow clones download only recent commit history, making cloning faster and using less disk space:
# Clone with only the latest commit
git clone --depth=1 https://github.com/user/repo.git
# Clone with last 50 commits
git clone --depth=50 https://github.com/user/repo.git
# Check if repository is shallow
git rev-parse --is-shallow-repository
# Output: true
# Convert shallow clone to full clone later
git fetch --unshallow
Use Cases for Shallow Clones:
- CI/CD pipelines (only need latest code)
- Deploying code (don't need full history)
- Large repositories with extensive history
- Limited disk space or bandwidth
Clone Specific Branch
Clone and checkout a specific branch:
# Clone only a specific branch
git clone --branch <branch-name> <repository-url>
# OR
git clone -b <branch-name> <repository-url>
# Example: Clone and checkout develop branch
git clone -b develop https://github.com/user/repo.git
# Combine with shallow clone
git clone --depth=1 -b develop https://github.com/user/repo.git
Clone Single Branch
Download only one branch, excluding others:
# Clone only specified branch (no other branches)
git clone --single-branch --branch main https://github.com/user/repo.git
# Later, if you need other branches:
git remote set-branches origin '*'
git fetch --all
# Or add specific branch:
git remote set-branches --add origin develop
git fetch origin develop
Note: --single-branch is useful when you only need one branch and want to save bandwidth and disk space, but limits your ability to work with other branches without additional configuration.
Bare Repositories
A bare repository has no working directory - it only contains Git data:
# Clone as bare repository
git clone --bare https://github.com/user/repo.git repo.git
# Bare repositories:
# - Have no working directory (no files to edit)
# - Used as central repositories on servers
# - Named with .git extension by convention
# - Can't commit directly (only receive pushes)
# Example structure:
repo.git/
├── HEAD
├── config
├── objects/
├── refs/
└── ...
Use Cases for Bare Repositories:
- Central server repositories
- Backup repositories
- Git hosting on your own server
- Repositories that only receive pushes
Mirror Clones
Mirror clones create an exact copy, including all refs:
# Create a mirror clone
git clone --mirror https://github.com/user/repo.git repo-mirror.git
# Mirror clones:
# - Are bare repositories
# - Include all refs (branches, tags, notes)
# - Map remote refs directly
# - Perfect for creating backups or migrating repositories
# Push mirror to new location:
cd repo-mirror.git
git push --mirror https://new-location.com/user/repo.git
Clone with Specific Remote Name
Change the default "origin" remote name:
# Clone with custom remote name
git clone --origin upstream https://github.com/user/repo.git
# Verify remote name
git remote -v
# upstream https://github.com/user/repo.git (fetch)
# upstream https://github.com/user/repo.git (push)
# Useful when setting up fork workflows
Clone with Submodules
Some repositories contain submodules (nested repositories):
# Clone repository and initialize submodules
git clone --recurse-submodules https://github.com/user/repo.git
# OR
git clone --recursive https://github.com/user/repo.git
# If you already cloned without submodules:
git submodule update --init --recursive
# Check submodule status
git submodule status
Tip: Always use --recurse-submodules if you know the repository contains submodules, otherwise subdirectories will be empty.
Clone Performance Options
Optimize cloning for speed and efficiency:
# Clone with progress display
git clone --progress https://github.com/user/repo.git
# Clone quietly (no output)
git clone --quiet https://github.com/user/repo.git
# OR
git clone -q https://github.com/user/repo.git
# Clone with verbose output
git clone --verbose https://github.com/user/repo.git
# OR
git clone -v https://github.com/user/repo.git
# Limit bandwidth (in KiB/s)
git clone --config http.postBuffer=1048576 https://github.com/user/repo.git
HTTPS vs SSH Cloning
Understanding the two main protocols:
HTTPS Cloning:
git clone https://github.com/user/repo.git
Advantages:
✓ Works everywhere (no firewall issues)
✓ Easy to set up
✓ No SSH keys needed
✓ Can use personal access tokens
Disadvantages:
✗ May require credentials for each operation
✗ Slightly slower than SSH
✗ Need to cache credentials or use tokens
SSH Cloning:
git clone git@github.com:user/repo.git
Advantages:
✓ No password prompts (uses SSH keys)
✓ More secure
✓ Faster authentication
✓ Better for automated scripts
Disadvantages:
✗ Requires SSH key setup
✗ May be blocked by strict firewalls
✗ Initial setup is more complex
Clone from Local Path
You can clone from a local directory:
# Clone from local path
git clone /path/to/local/repo new-copy
# Clone from local path as file:// URL
git clone file:///path/to/local/repo new-copy
# Clone from network path
git clone //server/share/repo.git new-copy
# This creates a complete independent copy
Use Case: Creating backup copies, testing changes in isolation, or working on the same project in multiple locations on your machine.
Partial Clone
Advanced feature to clone without downloading all objects:
# Clone without blobs (file contents)
git clone --filter=blob:none https://github.com/user/repo.git
# Clone without trees
git clone --filter=tree:0 https://github.com/user/repo.git
# Clone without large blobs (larger than 1MB)
git clone --filter=blob:limit=1m https://github.com/user/repo.git
# Objects are downloaded on-demand when needed
Advanced Feature: Partial clones are useful for very large repositories but require Git 2.19+ and server support. Use with caution as some Git operations may be slower.
Post-Clone Configuration
Common configurations after cloning:
# After cloning, configure your identity
git config user.name "Your Name"
git config user.email "your.email@example.com"
# Set up additional remotes (for fork workflow)
git remote add upstream https://github.com/original/repo.git
# Configure pull strategy
git config pull.rebase true
# Set up branch tracking
git branch --set-upstream-to=origin/main main
# Verify configuration
git config --list --local
Troubleshooting Clone Issues
Issue: "Permission denied (publickey)"
Cause: SSH key not set up or not added to GitHub
Solution:
# Generate SSH key
ssh-keygen -t ed25519 -C "your_email@example.com"
# Add to ssh-agent and GitHub account
# Or use HTTPS instead
Issue: "fatal: repository not found"
Cause: Wrong URL or no access to repository
Solution:
# Verify URL is correct
# Check repository exists and you have access
# For private repos, ensure authentication is set up
Issue: Clone is very slow
Solution:
# Use shallow clone
git clone --depth=1 https://github.com/user/repo.git
# Or use single branch
git clone --single-branch https://github.com/user/repo.git
Issue: "RPC failed; curl transfer closed"
Cause: Large repository or network issues
Solution:
git config --global http.postBuffer 524288000
git clone https://github.com/user/repo.git
Practice Exercise:
Clone and Explore:
# 1. Basic clone (use any public repository)
git clone https://github.com/octocat/Hello-World.git
cd Hello-World
# 2. Explore the cloned repository
git remote -v
git branch -a
git log --oneline -10
# 3. Try shallow clone
cd ..
git clone --depth=1 https://github.com/octocat/Hello-World.git shallow-repo
cd shallow-repo
git log --oneline # Only shows recent commits
# 4. Clone specific branch
cd ..
git clone -b main --single-branch https://github.com/octocat/Hello-World.git single-branch
cd single-branch
git branch -a # Only shows main branch
# 5. Clone with custom directory name
cd ..
git clone https://github.com/octocat/Hello-World.git my-custom-name
cd my-custom-name
# 6. Verify all clones
cd ..
ls -la
Clone Best Practices
✓ Use HTTPS for public repositories (easier)
✓ Use SSH for repositories you'll push to frequently
✓ Use shallow clones for CI/CD and deployment
✓ Clone specific branches when working on feature work
✓ Configure Git identity immediately after cloning
✓ Set up upstream remote for forked repositories
✓ Use --recurse-submodules if project has submodules
✓ Verify clone completed successfully before working
✗ Don't clone into existing Git repositories
✗ Don't clone with wrong protocol (check firewall rules)
✗ Avoid cloning very large repos without shallow option
Clone vs Fork vs Download
Clone:
- Creates local copy of repository
- Maintains connection to remote
- Can push/pull changes
- Full Git functionality
- Command: git clone
Fork (GitHub/GitLab feature):
- Creates your own copy on GitHub
- Independent repository under your account
- Used for contributing to projects
- Can create pull requests
- Done via web interface
Download ZIP:
- Downloads only current files
- No Git history
- No connection to remote
- Not a Git repository
- Can't push/pull changes
- Used for quick file access
Summary
In this lesson, you learned:
- git clone creates a complete local copy of a remote repository
- Clone automatically sets up "origin" remote and default branch
- Use --depth for shallow clones (faster, less space)
- Clone specific branches with -b flag
- Bare repositories have no working directory (server use)
- Mirror clones create exact copies including all refs
- HTTPS is easier, SSH is more convenient after setup
- Configure Git identity and remotes after cloning
- Use --recurse-submodules for projects with submodules
Next Up: In the next lesson, we'll explore working with tags for marking important points in your project history!