BLOG POSTS

MangoHost Blog / How to Install Git on Ubuntu 24

How to Install Git on Ubuntu 24

Setting up Git on Ubuntu 24 is one of those “duh, of course I need this” moments when you’re spinning up a new server. Whether you’re deploying applications, managing configuration files, or just need version control for your scripts, Git has become as essential as having SSH access to your box. This guide walks you through multiple installation methods, covers the gotchas you’ll encounter, and shows you how to integrate Git seamlessly into your server workflow. We’ll explore everything from the basic apt installation to compiling from source, plus some neat tricks that’ll make your life easier when managing repositories on production servers.

How Git Installation Works on Ubuntu 24

Ubuntu 24 handles Git installation through several pathways, each with its own trade-offs. The most straightforward approach uses Ubuntu’s package manager (apt), which pulls pre-compiled binaries from the official repositories. Under the hood, apt resolves dependencies, downloads the package, and configures Git with sensible defaults.

The package management system maintains three main Git-related packages:

git-core – The main Git package containing all essential commands
git-man – Manual pages and documentation
git-email – Tools for sending patches via email (optional but useful for kernel development)

When you install Git via apt, Ubuntu automatically handles the PATH configuration, creates necessary symlinks, and sets up the global configuration structure. The installation typically places binaries in /usr/bin/git and configuration templates in /usr/share/git-core/templates/.

Alternative installation methods include snap packages (containerized), building from source (maximum control), and using third-party PPAs (bleeding-edge versions). Each method affects where files are stored and how updates are managed.

Step-by-Step Installation Guide

Method 1: Standard APT Installation (Recommended for Most Users)

First, let’s update the package index and install Git using the default repository:

sudo apt update
sudo apt install git -y

Verify the installation:

git --version
which git

You should see output similar to:

git version 2.43.0
/usr/bin/git

Method 2: Installing Latest Version from Git PPA

Ubuntu’s default repositories sometimes lag behind the latest Git releases. For the newest features and security patches:

sudo add-apt-repository ppa:git-core/ppa -y
sudo apt update
sudo apt install git -y

Method 3: Building from Source (Maximum Control)

This method gives you complete control over compilation options and ensures you get the absolute latest version:

# Install build dependencies
sudo apt update
sudo apt install make libssl-dev libghc-zlib-dev libcurl4-gnutls-dev libxml2-dev libxslt-dev build-essential gettext unzip -y

# Download and compile Git
cd /tmp
wget https://github.com/git/git/archive/v2.45.0.tar.gz
tar -xzf v2.45.0.tar.gz
cd git-2.45.0
make configure
./configure --prefix=/usr/local
make -j$(nproc)
sudo make install

Method 4: Snap Installation (Containerized)

sudo snap install git-ubuntu --classic

Post-Installation Configuration

After installation, configure Git with your identity:

git config --global user.name "Your Name"
git config --global user.email "your.email@domain.com"
git config --global init.defaultBranch main

For server environments, consider these additional configurations:

# Improve performance for large repositories
git config --global core.preloadindex true
git config --global core.fscache true
git config --global gc.auto 256

# Set up credential caching (useful for automated deployments)
git config --global credential.helper cache
git config --global credential.helper 'cache --timeout=3600'

Real-World Examples and Use Cases

Deployment Automation Example

Here’s a practical script for automated deployments that many server admins use:

#!/bin/bash
# deploy.sh - Simple deployment script
REPO_URL="https://github.com/yourusername/yourproject.git"
DEPLOY_DIR="/var/www/html"
BRANCH="production"

cd $DEPLOY_DIR
git fetch origin
git reset --hard origin/$BRANCH
systemctl reload nginx

Configuration Management Use Case

Many sysadmins use Git to track configuration changes:

# Initialize tracking for system configs
sudo git init /etc
cd /etc
sudo git add nginx/ apache2/ ssh/
sudo git commit -m "Initial system configuration backup"

# Create a hook for automatic commits
sudo tee /etc/.git/hooks/post-commit << 'EOF'
#!/bin/bash
logger "Configuration change committed: $(git log -1 --oneline)"
EOF
sudo chmod +x /etc/.git/hooks/post-commit

Performance Comparison Table

Installation Method	Install Time	Version Currency	Maintenance Effort	Disk Usage
APT (default)	~30 seconds	Stable, sometimes outdated	Low (automatic updates)	~15MB
APT (PPA)	~45 seconds	Latest stable	Low (automatic updates)	~15MB
Source compilation	5-10 minutes	Bleeding edge	High (manual updates)	~25MB
Snap	~60 seconds	Recent	Low (automatic updates)	~45MB

Common Issues and Solutions

Problem: Git commands fail with “command not found”

# Solution: Check if Git is in PATH
echo $PATH
# If missing, add to ~/.bashrc:
echo 'export PATH=$PATH:/usr/local/bin' >> ~/.bashrc
source ~/.bashrc

Problem: Permission denied when accessing repositories

# Solution: Set up SSH keys for Git operations
ssh-keygen -t ed25519 -C "your.email@domain.com"
cat ~/.ssh/id_ed25519.pub
# Add this public key to your Git provider

Integration with Other Tools

Git pairs excellently with other server management tools:

Docker + Git: Create automated builds triggered by Git webhooks
Ansible + Git: Store playbooks in Git for infrastructure as code
Jenkins + Git: Set up CI/CD pipelines with Git integration
Cron + Git: Schedule automatic repository updates and backups

Example Docker integration:

# Dockerfile that pulls latest code
FROM ubuntu:24.04
RUN apt update && apt install git -y
WORKDIR /app
RUN git clone https://github.com/yourproject/app.git .
CMD ["./start.sh"]

Interesting Statistics and Facts

Git’s performance on Ubuntu 24 shows impressive numbers:

Installation via APT completes in under 30 seconds on a standard VPS
Git can handle repositories with millions of files efficiently
The Linux kernel repository (managed with Git) contains over 1 million commits
Git’s distributed nature means every clone is a complete backup

For server deployments, consider getting a VPS with adequate storage for your repositories, or if you’re managing multiple large projects, a dedicated server might be more appropriate.

Advanced Configuration and Automation

Server-Specific Git Hooks

Git hooks enable powerful automation scenarios. Here’s a post-receive hook for automatic deployments:

#!/bin/bash
# /path/to/repo.git/hooks/post-receive
while read oldrev newrev refname; do
    if [[ $refname == "refs/heads/main" ]]; then
        echo "Deploying to production..."
        cd /var/www/production
        git --git-dir=/path/to/repo.git --work-tree=/var/www/production checkout -f main
        systemctl reload nginx
        echo "Deployment complete!"
    fi
done

Git LFS for Large Files

When dealing with large assets on servers:

sudo apt install git-lfs
git lfs install
git lfs track "*.zip" "*.tar.gz" "*.deb"
git add .gitattributes

Monitoring Git Operations

Create a simple monitoring script for Git operations:

#!/bin/bash
# git-monitor.sh
LOG_FILE="/var/log/git-operations.log"
REPO_DIR="/var/www/html"

cd $REPO_DIR
CURRENT_COMMIT=$(git rev-parse HEAD)
git fetch --quiet

if [ "$(git rev-parse HEAD)" != "$(git rev-parse @{u})" ]; then
    echo "$(date): Repository has updates available" >> $LOG_FILE
    git pull >> $LOG_FILE 2>&1
    systemctl reload nginx
fi

Troubleshooting Common Issues

SSL Certificate Problems

# If you encounter SSL certificate errors:
git config --global http.sslverify false  # Not recommended for production
# Better solution:
sudo apt update && sudo apt install ca-certificates -y

Large Repository Performance

# For better performance with large repositories:
git config --global core.bigFileThreshold 100m
git config --global pack.windowMemory 100m
git config --global pack.packSizeLimit 100m

Memory Issues During Clone

# For memory-constrained servers:
git clone --depth 1 <repository-url>  # Shallow clone
git config --global pack.threads 1     # Reduce CPU usage

Security Considerations

When running Git on production servers, security becomes paramount:

Use SSH keys instead of HTTPS authentication for better security
Restrict Git operations to specific users with sudo configurations
Regular updates – Git security patches are critical
Repository permissions – Ensure proper file ownership and permissions

# Set up secure Git operations
sudo groupadd git-users
sudo usermod -aG git-users $USER
sudo chown -R root:git-users /opt/repositories
sudo chmod -R 775 /opt/repositories

Conclusion and Recommendations

Installing Git on Ubuntu 24 is straightforward, but choosing the right method depends on your specific needs. For most server administrators, the standard APT installation provides the perfect balance of stability, ease of maintenance, and functionality. The PPA route gives you more recent versions without the complexity of source compilation, making it ideal for production environments that need newer features.

Source compilation makes sense when you need specific compile-time options or are working with cutting-edge features, but the maintenance overhead usually isn’t worth it for typical server deployments. Snap installation works well in containerized environments but comes with additional storage overhead.

My recommendations:

Development servers: Use the Git PPA for latest features
Production servers: Stick with the default APT installation for stability
CI/CD environments: Consider containerized installations with Docker
High-performance scenarios: Compile from source with optimized flags

Git opens up incredible possibilities for automation, deployment, and configuration management on Ubuntu servers. From simple deployment scripts to complex CI/CD pipelines, having Git properly configured is the foundation for modern server management practices. Whether you’re managing a simple VPS or running multiple applications on a dedicated server, Git will become an indispensable part of your toolkit.

Remember to regularly update your Git installation, especially for security patches, and always test your Git-based automation in staging environments before deploying to production. The time invested in properly setting up Git will pay dividends in improved deployment reliability and easier maintenance workflows.

For additional information and advanced Git configurations, check out the official documentation at git-scm.com/doc and the Ubuntu-specific package information at packages.ubuntu.com.

This article incorporates information and material from various online sources. We acknowledge and appreciate the work of all original authors, publishers, and websites. While every effort has been made to appropriately credit the source material, any unintentional oversight or omission does not constitute a copyright infringement. All trademarks, logos, and images mentioned are the property of their respective owners. If you believe that any content used in this article infringes upon your copyright, please contact us immediately for review and prompt action.

This article is intended for informational and educational purposes only and does not infringe on the rights of the copyright owners. If any copyrighted material has been used without proper credit or in violation of copyright laws, it is unintentional and we will rectify it promptly upon notification. Please note that the republishing, redistribution, or reproduction of part or all of the contents in any form is prohibited without express written permission from the author and website owner. For permissions or further inquiries, please contact us.