Gitea: Lightweight Self-Hosted Git Service

Overview

GitHub is great until you want control over your code, your data, and your infrastructure. GitLab is powerful but demands 4-8GB of RAM just to start. Gitea hits the sweet spot: a fully-featured Git hosting solution that runs comfortably on 512MB of RAM, yet provides nearly everything you’d expect from the big players.

Think of Gitea as GitHub’s lightweight cousin designed specifically for self-hosting. It provides Git repository hosting, pull requests, issue tracking, wikis, project management, and even built-in CI/CD with Gitea Actions. All packaged in a single binary under 100MB that you can deploy in minutes.

In 2025, Gitea has matured into a production-ready platform powering thousands of organizations’ development workflows. Whether you’re managing personal projects, running a small development team, or building a complete DevOps pipeline in your homelab, Gitea delivers enterprise features without enterprise resource requirements.

What you’ll learn:

• Installing Gitea with Docker and Docker Compose
• Configuring SSH for Git operations
• Setting up repository mirroring from GitHub/GitLab
• Implementing webhooks for automation
• Integrating with CI/CD pipelines
• Migrating repositories and data
• Security hardening and backup strategies

Why Gitea for your homelab?

Complete control over your source code, lightweight enough for a Raspberry Pi, powerful enough for serious development work. Mirror critical repositories from GitHub as backups. Build CI/CD pipelines that deploy directly to your infrastructure. Collaborate with your team without relying on external services or paying per-user fees.

---

Prerequisites

Before starting, ensure you have:

• Linux server with Docker installed (512MB+ RAM minimum, 1-2GB recommended)
• Docker and Docker Compose installed and working
• Storage: 10GB+ for repositories and data
• Network: Ports 3000 (web UI) and 22 or 2222 (SSH)
• Basic Git knowledge (commits, pushes, pulls, branches)

Optional but helpful:

• Domain name for HTTPS access
• Reverse proxy (Nginx Proxy Manager, Traefik, Caddy)
• Understanding of SSH key authentication
• Familiarity with webhooks and CI/CD concepts

---

Understanding Gitea Architecture

What is Gitea?

Gitea is a painless self-hosted Git service written in Go. It’s a community-managed fork of Gogs, designed to be lightweight, fast, and easy to install. The entire application compiles to a single binary with no external dependencies.

Core features:

• Git repository hosting with web interface
• User and organization management
• Issue tracking and project boards
• Pull requests and code review
• Repository wikis and documentation
• Package registry for various formats
• Webhooks and integrations
• Built-in CI/CD (Gitea Actions)
• Repository mirroring
• OAuth2 provider and consumer

Gitea vs. Alternatives

When to choose Gitea:

• You need GitHub-like features on limited hardware
• You want quick deployment and easy maintenance
• You need CI/CD without complex configuration
• You value simplicity and resource efficiency
• You’re migrating from GitHub and want familiar workflows

How Gitea Works

User Browser
    ↓
[Gitea Web UI (Port 3000)]
    ↓
[Gitea Application Logic]
    ↓
[SQLite/PostgreSQL/MySQL Database]
    ↓
[Git Repositories on Disk]

SSH Client (git push/pull)
    ↓
[Gitea SSH Server (Port 22/2222)]
    ↓
[Authentication & Authorization]
    ↓
[Git Repositories on Disk]

Gitea handles both HTTP(S) and SSH Git operations, stores metadata in a database, and keeps actual Git repositories as standard Git directories on disk.

---

Installing Gitea

Method 1: Docker Compose (Recommended)

This is the most flexible and maintainable approach for homelabs.

Create directory structure:

mkdir -p ~/gitea && cd ~/gitea

Create docker-compose.yml:

version: '3.8'

services:
  gitea:
    image: gitea/gitea:1.21
    container_name: gitea
    restart: unless-stopped
    environment:
      - USER_UID=1000
      - USER_GID=1000
      - GITEA__database__DB_TYPE=postgres
      - GITEA__database__HOST=db:5432
      - GITEA__database__NAME=gitea
      - GITEA__database__USER=gitea
      - GITEA__database__PASSWD=${DB_PASSWORD}
      - GITEA__server__DOMAIN=${GITEA_DOMAIN}
      - GITEA__server__SSH_DOMAIN=${GITEA_DOMAIN}
      - GITEA__server__ROOT_URL=https://${GITEA_DOMAIN}
      - GITEA__server__HTTP_PORT=3000
      - GITEA__server__SSH_PORT=22
      - GITEA__server__START_SSH_SERVER=true
      - GITEA__service__DISABLE_REGISTRATION=false
      - GITEA__mailer__ENABLED=false
    ports:
      - "3000:3000"
      - "2222:22"  # SSH on host port 2222
    volumes:
      - gitea_data:/data
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    networks:
      - gitea
    depends_on:
      - db

  db:
    image: postgres:15-alpine
    container_name: gitea-db
    restart: unless-stopped
    environment:
      - POSTGRES_USER=gitea
      - POSTGRES_PASSWORD=${DB_PASSWORD}
      - POSTGRES_DB=gitea
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - gitea
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U gitea"]
      interval: 10s
      timeout: 5s
      retries: 5

volumes:
  gitea_data:
    driver: local
  postgres_data:
    driver: local

networks:
  gitea:
    driver: bridge

Create .env file:

nano .env

# Database password (change this!)
DB_PASSWORD=your_secure_password_here

# Your domain (or IP address)
GITEA_DOMAIN=git.homelab.local

Deploy Gitea:

# Start services
docker compose up -d

# Check logs
docker compose logs -f gitea

# Verify containers are running
docker compose ps

Access Gitea:

Navigate to http://YOUR-SERVER-IP:3000 or http://git.homelab.local:3000

Method 2: Standalone Docker Container

For simpler setups using SQLite instead of PostgreSQL:

docker run -d   --name=gitea   --restart=unless-stopped   -p 3000:3000   -p 2222:22   -v gitea_data:/data   -e USER_UID=1000   -e USER_GID=1000   gitea/gitea:1.21

This uses SQLite (built-in database) and is perfect for personal use or testing.

Initial Configuration

On first access, you’ll see the installation wizard:

Database Settings (if using PostgreSQL):

• Database Type: PostgreSQL
• Host: db:5432
• Username: gitea
• Password: (from your .env file)
• Database Name: gitea

General Settings:

• Site Title: Your Homelab Git
• Repository Root Path: /data/git/repositories
• Git LFS Root Path: /data/git/lfs
• Run As Username: git

Server and Third-Party Service Settings:

• SSH Server Domain: git.homelab.local
• SSH Port: 22 (internal, mapped to 2222 on host)
• Gitea HTTP Listen Port: 3000
• Gitea Base URL: http://git.homelab.local:3000
• Log Path: /data/gitea/log

Administrator Account:

• Administrator Username: admin
• Password: (choose a strong password)
• Email Address: [email protected]

Optional Settings:

• Email Settings: Leave disabled unless you have SMTP configured
• Server and Third-Party Services: Can configure later
• Disable Self-Registration: Enable if you want invite-only

Click Install Gitea to complete setup.

---

SSH Configuration

SSH is essential for efficient Git operations. Let’s configure it properly.

Understanding SSH Port Mapping

The container runs SSH on port 22 internally, but we map it to 2222 on the host to avoid conflicts with the host’s own SSH server.

Git clone URLs will look like:

# HTTPS (always works, but requires password/token)
git clone https://git.homelab.local/username/repo.git

# SSH (efficient, uses key authentication)
git clone ssh://[email protected]:2222/username/repo.git

Setting Up SSH Keys

On your local machine:

# Generate SSH key (if you don't have one)
ssh-keygen -t ed25519 -C "[email protected]"

# Display your public key
cat ~/.ssh/id_ed25519.pub

Add SSH key to Gitea:

1. Log into Gitea web interface
2. Click your profile picture → Settings
3. Navigate to SSH / GPG Keys
4. Click Add Key
5. Paste your public key
6. Give it a name (e.g., “MacBook Pro”)
7. Click Add Key

Test SSH connection:

# Test connection (use host port 2222)
ssh -p 2222 -T [email protected]

# Expected output:
# Hi there, username! You've successfully authenticated,
# but Gitea does not provide shell access.

Configuring Git for Gitea

Set SSH port in Git config:

# Edit SSH config
nano ~/.ssh/config

Add this configuration:

Host git.homelab.local
    HostName git.homelab.local
    Port 2222
    User git
    IdentityFile ~/.ssh/id_ed25519

Now you can clone without specifying the port:

git clone [email protected]:username/repo.git

Configure Git globally:

git config --global user.name "Your Name"
git config --global user.email "[email protected]"

---

Repository Management

Creating Your First Repository

Via Web Interface:

1. Click + icon → New Repository
2. Configure:
   • Owner: Your username
   • Repository Name: my-first-repo
   • Description: My first Gitea repository
   • Visibility: Private
   • Initialize Repository: Check this
   • Add .gitignore: Select template (optional)
   • Add License: Select license (optional)
3. Click Create Repository

Clone and push code:

# Clone the repository
git clone [email protected]:username/my-first-repo.git
cd my-first-repo

# Create a file
echo "# My First Repo" > README.md

# Commit and push
git add README.md
git commit -m "Initial commit"
git push origin main

Repository Mirroring

Mirror repositories from GitHub, GitLab, or other Gitea instances as backups or for offline access.

Mirror a GitHub repository:

1. Go to + → New Migration
2. Select GitHub as source
3. Configure:
   • Clone Address: https://github.com/username/repo.git
   • Migration Options:
     • Mirror: Yes (keeps synchronized)
     • Private: Yes/No
   • GitHub Access Token: (if private repo)
4. Click Migrate Repository

Automatic synchronization:

Gitea will periodically pull updates from the source. Configure sync interval:

1. Go to repository Settings
2. Navigate to Repository → Mirror Settings
3. Set Mirror Sync Interval (e.g., 8h)
4. Click Update Settings

Manual sync:

# Via web UI: Repository → Settings → Sync Now

# Via API:
curl -X POST "https://git.homelab.local/api/v1/repos/username/repo/mirror-sync"   -H "Authorization: token YOUR_API_TOKEN"

Repository Migration

Move existing repositories from GitHub, GitLab, or other services.

Migrate from GitHub:

1. + → New Migration
2. GitHub source
3. Enter repository URL
4. Provide GitHub Personal Access Token (for private repos)
5. Select what to migrate:
   • Repository
   • Issues
   • Pull Requests
   • Releases
   • Milestones
   • Labels
   • Wiki
6. Click Migrate Repository

Migrate multiple repositories:

Use Gitea’s batch migration feature or the API:

# Using Gitea CLI (tea)
tea login add --name homelab --url https://git.homelab.local --token YOUR_TOKEN

# Migrate repository
tea migrate repo   --source github   --token GITHUB_TOKEN   --owner username   --name repo-name

Organizations and Teams

Create an organization:

1. Click + → New Organization
2. Configure:
   • Organization Name: devteam
   • Visibility: Private
   • Description: Development team repositories
3. Click Create Organization

Add team members:

1. Go to organization → Teams
2. Click New Team
3. Configure permissions:
   • Team Name: developers
   • Permission: Write
   • Units: Code, Issues, Pull Requests
4. Add members by username
5. Click Create Team

Assign repositories to teams:

1. Organization → Repositories
2. Click repository → Settings → Collaboration
3. Add team with desired access level

---

Webhooks and Integrations

Webhooks notify external services when events occur in your repositories.

Setting Up Webhooks

Create a webhook:

1. Go to repository → Settings → Webhooks
2. Click Add Webhook → Gitea or Custom
3. Configure:
   • Target URL: https://your-service.com/webhook
   • HTTP Method: POST
   • POST Content Type: application/json
   • Secret: (optional, for security)
   • Trigger Events: Choose which events
     • Push
     • Create
     • Delete
     • Release
     • Pull Request
     • Issues
4. Click Add Webhook

Test webhook:

Click Test Delivery to send a test payload.

Webhook payload example (push event):

{
  "secret": "webhook-secret",
  "ref": "refs/heads/main",
  "before": "abc123...",
  "after": "def456...",
  "compare_url": "https://git.homelab.local/user/repo/compare/abc123...def456",
  "commits": [
    {
      "id": "def456...",
      "message": "Update README",
      "url": "https://git.homelab.local/user/repo/commit/def456",
      "author": {
        "name": "Your Name",
        "email": "[email protected]"
      },
      "timestamp": "2025-12-16T10:30:00Z"
    }
  ],
  "repository": {
    "name": "my-repo",
    "full_name": "username/my-repo",
    "html_url": "https://git.homelab.local/username/my-repo"
  },
  "pusher": {
    "login": "username",
    "email": "[email protected]"
  }
}

Integration Examples

Trigger deployment on push:

Use webhooks to deploy code automatically when you push to specific branches.

Webhook receiver (Node.js example):

const express = require('express');
const crypto = require('crypto');
const { exec } = require('child_process');

const app = express();
app.use(express.json());

const WEBHOOK_SECRET = 'your-webhook-secret';

function verifySignature(payload, signature) {
  const hmac = crypto.createHmac('sha256', WEBHOOK_SECRET);
  const digest = hmac.update(JSON.stringify(payload)).digest('hex');
  return signature === digest;
}

app.post('/webhook', (req, res) => {
  const signature = req.headers['x-gitea-signature'];

  if (!verifySignature(req.body, signature)) {
    return res.status(401).send('Invalid signature');
  }

  const { ref, repository } = req.body;

  // Only deploy on main branch push
  if (ref === 'refs/heads/main') {
    console.log(`Deploying ${repository.full_name}...`);

    exec('/opt/scripts/deploy.sh', (error, stdout, stderr) => {
      if (error) {
        console.error(`Deployment failed: ${error}`);
        return res.status(500).send('Deployment failed');
      }
      console.log(`Deployment output: ${stdout}`);
      res.send('Deployment triggered');
    });
  } else {
    res.send('Ignored (not main branch)');
  }
});

app.listen(3001, () => {
  console.log('Webhook receiver listening on port 3001');
});

Notify Discord/Slack on push:

Use webhook services or custom scripts to send notifications:

#!/bin/bash
# discord-notify.sh

WEBHOOK_URL="https://discord.com/api/webhooks/..."

COMMIT_MSG=$(git log -1 --pretty=format:"%s")
COMMIT_AUTHOR=$(git log -1 --pretty=format:"%an")
REPO_NAME=$(basename $(git rev-parse --show-toplevel))

curl -X POST "$WEBHOOK_URL"   -H "Content-Type: application/json"   -d "{
    "content": "📦 New push to **${REPO_NAME}**",
    "embeds": [{
      "title": "${COMMIT_MSG}",
      "description": "Pushed by ${COMMIT_AUTHOR}",
      "color": 3447003
    }]
  }"

---

CI/CD with Gitea Actions

Gitea Actions provides GitHub Actions-compatible CI/CD built into Gitea.

Enabling Gitea Actions

Edit app.ini (Docker: in gitea_data/gitea/conf/app.ini):

[actions]
ENABLED = true
DEFAULT_ACTIONS_URL = https://github.com

Restart Gitea:

docker compose restart gitea

Setting Up Runners

Gitea Actions requires runners to execute workflows. See the dedicated Gitea Actions guide for full setup instructions.

Quick runner setup:

# Download act runner
curl -L https://dl.gitea.com/act_runner/latest/act_runner-linux-amd64 -o act_runner
chmod +x act_runner

# Register runner
./act_runner register   --instance http://git.homelab.local:3000   --token YOUR_REGISTRATION_TOKEN   --name docker-runner-01

# Run runner
./act_runner daemon

Example Workflow

Create .gitea/workflows/build.yml in your repository:

name: Build and Test

on:
  push:
    branches:
      - main
  pull_request:

jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install dependencies
        run: npm ci

      - name: Run tests
        run: npm test

      - name: Build application
        run: npm run build

      - name: Upload artifacts
        uses: actions/upload-artifact@v4
        with:
          name: build-output
          path: dist/

For comprehensive CI/CD setup, refer to our Gitea Actions guide.

---

Security and Access Control

User Management

Create users:

1. Admin panel → User Accounts
2. Click Create User Account
3. Fill in details (username, email, password)
4. Set permissions:
   • May Create Organizations: Yes/No
   • Administrator: Yes/No
   • Restricted: (limited access)
5. Click Create User Account

User permissions levels:

• Administrator: Full system access
• User: Normal access, can create repos
• Restricted: Cannot create public repos
• Prohibited Login: Account disabled

Authentication Methods

Configure authentication in app.ini:

LDAP/Active Directory:

[auth.ldap]
ENABLED = true
HOST = ldap.homelab.local
PORT = 389
BIND_DN = cn=gitea,ou=services,dc=homelab,dc=local
BIND_PASSWORD = password
USER_BASE = ou=users,dc=homelab,dc=local
USER_DN = uid=%s,ou=users,dc=homelab,dc=local
ATTRIBUTE_USERNAME = uid
ATTRIBUTE_NAME = cn
ATTRIBUTE_SURNAME = sn
ATTRIBUTE_MAIL = mail

OAuth2 (GitHub, Google, etc):

1. Admin → Authentication Sources
2. Add Authentication Source
3. Select OAuth2
4. Choose provider and configure client ID/secret

Two-Factor Authentication (2FA):

Users can enable 2FA in their account settings:

1. User Settings → Security
2. Two-Factor Authentication → Enroll
3. Scan QR code with authenticator app
4. Enter verification code
5. Save recovery codes securely

Access Tokens

Create personal access token:

1. User Settings → Applications
2. Generate New Token
3. Configure scopes:
   • read:repository
   • write:repository
   • read:user
   • write:user
4. Copy token (shown only once!)

Use token for API access:

# Clone with token
git clone https://username:[email protected]/username/repo.git

# API request
curl -H "Authorization: token YOUR_TOKEN"   https://git.homelab.local/api/v1/user/repos

Repository Permissions

Access levels:

• Read: View code, clone repository
• Write: Push commits, create branches
• Admin: Manage settings, delete repository
• Owner: Full control including transfer

Branch protection:

1. Repository → Settings → Branches
2. Select branch → Edit
3. Configure protection rules:
   • Require pull request reviews
   • Require status checks to pass
   • Require signed commits
   • Block force pushes
   • Lock branch (read-only)
4. Click Save

---

Backup and Maintenance

Backing Up Gitea

What to backup:

1. Database (PostgreSQL or SQLite)
2. Git repositories (in gitea_data)
3. Configuration files (app.ini)
4. Uploaded attachments and avatars

Backup script:

#!/bin/bash
# gitea-backup.sh

BACKUP_DIR="/opt/backups/gitea"
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_FILE="gitea_backup_${DATE}.tar.gz"

# Create backup directory
mkdir -p "$BACKUP_DIR"

# Stop Gitea (optional, for consistency)
docker compose stop gitea

# Backup using Gitea's built-in command
docker exec gitea-db pg_dump -U gitea gitea > "$BACKUP_DIR/gitea_db_${DATE}.sql"

# Backup data directory
tar czf "$BACKUP_DIR/$BACKUP_FILE"   -C /var/lib/docker/volumes   gitea_gitea_data

# Restart Gitea
docker compose start gitea

# Cleanup old backups (keep last 7 days)
find "$BACKUP_DIR" -name "gitea_backup_*.tar.gz" -mtime +7 -delete

echo "Backup completed: $BACKUP_FILE"

Automate backups:

# Add to crontab
crontab -e

# Run backup daily at 2 AM
0 2 * * * /opt/scripts/gitea-backup.sh

Restore from Backup

# Stop Gitea
docker compose down

# Restore database
cat gitea_db_20251216.sql | docker exec -i gitea-db psql -U gitea gitea

# Restore data directory
tar xzf gitea_backup_20251216.tar.gz -C /var/lib/docker/volumes/

# Start Gitea
docker compose up -d

Updating Gitea

Check for updates:

Visit Gitea releases for latest version.

Update process:

# Backup first!
./gitea-backup.sh

# Update docker-compose.yml to new version
nano docker-compose.yml
# Change: image: gitea/gitea:1.21 → gitea/gitea:1.22

# Pull new image
docker compose pull gitea

# Recreate container
docker compose up -d gitea

# Check logs
docker compose logs -f gitea

# Verify version
curl http://git.homelab.local:3000/api/v1/version

Gitea performs automatic database migrations on startup.

Monitoring

Check Gitea health:

# Via API
curl http://git.homelab.local:3000/api/healthz

# Check metrics (if enabled)
curl http://git.homelab.local:3000/metrics

Enable Prometheus metrics in app.ini:

[metrics]
ENABLED = true
TOKEN = your-secret-token

Monitor with Prometheus:

# prometheus.yml
scrape_configs:
  - job_name: 'gitea'
    static_configs:
      - targets: ['git.homelab.local:3000']
    metrics_path: '/metrics'
    bearer_token: 'your-secret-token'

---

Advanced Configuration

Customization

Custom logo and branding:

1. Place custom logo in gitea_data/gitea/public/img/logo.png
2. Edit app.ini:

[ui]
DEFAULT_THEME = auto
THEMES = auto,gitea,arc-green

Custom CSS:

Create gitea_data/gitea/public/css/custom.css

Email notifications:

[mailer]
ENABLED = true
FROM = [email protected]
PROTOCOL = smtp
SMTP_ADDR = smtp.gmail.com
SMTP_PORT = 587
USER = [email protected]
PASSWD = app-password

Performance Tuning

For larger deployments:

[server]
DISABLE_SSH = false
START_SSH_SERVER = true
BUILTIN_SSH_SERVER_USER = git

[database]
MAX_OPEN_CONNS = 100
MAX_IDLE_CONNS = 50

[cache]
ENABLED = true
ADAPTER = redis
HOST = redis:6379

[session]
PROVIDER = redis
PROVIDER_CONFIG = redis:6379

Add Redis for caching:

# Add to docker-compose.yml
  redis:
    image: redis:7-alpine
    container_name: gitea-redis
    restart: unless-stopped
    networks:
      - gitea

API Usage

List repositories:

curl -H "Authorization: token YOUR_TOKEN"   https://git.homelab.local/api/v1/user/repos

Create repository:

curl -X POST   -H "Authorization: token YOUR_TOKEN"   -H "Content-Type: application/json"   -d '{"name":"new-repo","description":"Created via API","private":true}'   https://git.homelab.local/api/v1/user/repos

Full API documentation: Available at https://git.homelab.local/api/swagger

---

Troubleshooting

SSH Connection Issues

Problem: SSH connection fails

# Test SSH
ssh -vvv -p 2222 [email protected]

# Check if port is open
nc -zv git.homelab.local 2222

# Verify container SSH service
docker exec gitea ps aux | grep ssh

Solution: Ensure port mapping is correct and firewall allows 2222.

Repository Clone Failures

Problem: fatal: unable to access

# Check Gitea logs
docker compose logs gitea | tail -50

# Verify repository exists
curl https://git.homelab.local/api/v1/repos/username/repo

# Check permissions
# Ensure user has read access to repository

Database Connection Errors

Problem: Gitea can’t connect to database

# Check database health
docker exec gitea-db pg_isready -U gitea

# View database logs
docker compose logs db

# Verify connection from Gitea
docker exec gitea nc -zv db 5432

Performance Issues

Problem: Slow web interface or Git operations

# Check resource usage
docker stats gitea gitea-db

# Increase resources in docker-compose.yml
deploy:
  resources:
    limits:
      memory: 2G

# Enable caching (add Redis)

---

Conclusion

Gitea brings enterprise-grade Git hosting to your homelab without enterprise-grade resource requirements. You now have:

• A fully functional self-hosted Git service
• SSH and HTTPS access configured
• Repository management and mirroring capabilities
• Webhook integrations for automation
• CI/CD foundation with Gitea Actions
• Backup and maintenance procedures

Key Takeaways

• Lightweight: Runs on 512MB RAM, perfect for homelabs
• Feature-rich: Issues, PRs, wikis, packages, CI/CD
• GitHub-compatible: Familiar workflows and Actions syntax
• Self-hosted: Complete control over your code and data
• Easy maintenance: Single binary, simple updates

Next Steps

1. Mirror critical repositories from GitHub as backups
2. Set up CI/CD with Gitea Actions for automated builds
3. Configure webhooks to automate deployments
4. Implement automated backups for your repositories
5. Explore integrations with your other homelab services

Related Guides

• Gitea Actions - Full CI/CD pipeline setup
• Forgejo - Community-driven Gitea fork comparison
• Woodpecker CI - Alternative CI/CD for Gitea
• MinIO - Object storage for Git LFS
• Nginx Proxy Manager - Reverse proxy with HTTPS

Resources

• Official Documentation: docs.gitea.io
• GitHub Repository: github.com/go-gitea/gitea
• Community Forum: discourse.gitea.io
• API Documentation: Your Gitea instance at /api/swagger

---

Document Version: 1.0 Last Updated: December 16, 2025 Based on: Gitea 1.21+ Estimated Completion Time: 45 minutes

Happy self-hosting!