Configuración de Servidor Git Privado: Guía Completa de Solución Git Auto-Hospedada

En el panorama actual del desarrollo, el control de versiones es esencial para gestionar código, colaborar con equipos y mantener el historial del proyecto. Si bien las soluciones basadas en la nube como GitHub, GitLab y Bitbucket son populares, alojar tu propio servidor Git privado ofrece control completo sobre tu código, seguridad mejorada y libertad de dependencias de terceros. Esta guía completa te lleva a través de la configuración, configuración y gestión de un servidor Git privado en tu propia infraestructura.

Introducción

Un servidor Git privado proporciona infraestructura de control de versiones centralizada bajo tu completo control. Ya sea que te preocupe la soberanía de datos, necesites seguridad mejorada para código propietario, quieras evitar costos de suscripción o simplemente prefieras soluciones auto-hospedadas, configurar tu propio servidor Git es un objetivo práctico y alcanzable.

¿Por Qué Alojar Tu Propio Servidor Git?

Seguridad y Privacidad: Tu código nunca sale de tu infraestructura, dándote control completo sobre el acceso y la protección de datos. Esto es crucial para organizaciones que manejan propiedad intelectual sensible u operan bajo requisitos de cumplimiento estrictos.

Eficiencia de Costos: Después de la configuración inicial, los costos de alojamiento son típicamente más bajos que las soluciones Git empresariales en la nube, especialmente para equipos más grandes o colecciones extensas de repositorios.

Personalización: Control completo sobre el entorno del servidor permite integraciones personalizadas, estrategias de respaldo y flujos de trabajo adaptados a tus necesidades específicas.

Sin Dependencia de Proveedor: La independencia de proveedores de servicios de terceros significa que no hay preocupaciones sobre cambios de servicio, aumentos de precios o disponibilidad de la plataforma.

Oportunidad de Aprendizaje: Configurar un servidor Git profundiza tu comprensión de la arquitectura de Git y la administración de servidores.

Enfoques de Servidor Git

Esta guía cubre múltiples enfoques para alojar Git, desde soluciones básicas basadas en SSH hasta interfaces web completas:

  1. Servidor Git SSH Básico: Simple, seguro, enfocado en línea de comandos
  2. Gitolite: Control de acceso avanzado con sobrecarga mínima
  3. Gitea: Servicio Git ligero y autocontenido con interfaz web
  4. GitLab CE: Plataforma DevOps completa con integración CI/CD

Cada enfoque tiene diferentes requisitos de recursos, conjuntos de características y niveles de complejidad, permitiéndote elegir la solución que mejor se adapte a tus necesidades.

Requisitos Previos

Antes de comenzar la instalación, asegúrate de tener:

Requisitos del Sistema

Requisitos Mínimos (Servidor Git SSH Básico):

  • Servidor Linux (Ubuntu 20.04+, Debian 11+, CentOS 8+, Rocky Linux 8+)
  • 1 núcleo de CPU
  • 512MB RAM
  • 10GB de espacio en disco
  • Acceso root o sudo

Requisitos Recomendados (Gitea):

  • 2 núcleos de CPU
  • 2GB RAM
  • 20GB+ de espacio en disco (dependiendo del tamaño del repositorio)
  • Nombre de dominio o dirección IP estática

Requisitos Recomendados (GitLab CE):

  • 4 núcleos de CPU
  • 4GB RAM (8GB recomendado)
  • 50GB+ de espacio en disco
  • Nombre de dominio con certificado SSL

Software Requerido

  • Git (versión 2.x o superior)
  • Servidor SSH (OpenSSH)
  • Editor de texto (vim, nano o alternativa preferida)
  • Servidor web (Nginx o Apache) para soluciones basadas en web
  • Base de datos (PostgreSQL o MySQL) para Gitea/GitLab

Requisitos de Red

  • Puerto SSH 22 (o puerto personalizado) abierto para operaciones Git
  • Puerto 80/443 para interfaz web (soluciones basadas en web)
  • Dirección IP estática o DNS dinámico para acceso consistente
  • Nombre de dominio (opcional pero recomendado para soluciones basadas en web)

Requisitos Previos de Seguridad

  • Firewall configurado (UFW, firewalld o iptables)
  • Autenticación basada en claves SSH configurada
  • Solución de respaldo regular planificada
  • Certificados SSL/TLS para HTTPS (Let's Encrypt recomendado)

Instalación

Método 1: Servidor Git SSH Básico

El servidor Git más simple requiere solo acceso SSH e instalación de Git. Este método es ideal para equipos pequeños o uso personal.

Paso 1: Instalar Git

# Ubuntu/Debian
sudo apt update
sudo apt install -y git

# CentOS/Rocky Linux
sudo dnf install -y git

Verificar instalación:

git --version

Paso 2: Crear Usuario Git

Crear un usuario dedicado para operaciones Git:

sudo adduser git
sudo passwd git  # Establecer una contraseña segura

Paso 3: Configurar Acceso SSH

Configurar autenticación basada en claves SSH:

# Cambiar al usuario git
sudo su - git

# Crear directorio SSH
mkdir -p ~/.ssh
chmod 700 ~/.ssh
touch ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys

Agregar claves públicas SSH de clientes a ~/.ssh/authorized_keys:

# En la máquina cliente, generar clave SSH si es necesario
ssh-keygen -t ed25519 -C "[email protected]"

# Copiar clave pública al servidor
cat ~/.ssh/id_ed25519.pub | ssh git@tu-servidor "cat >> ~/.ssh/authorized_keys"

Paso 4: Crear Directorio de Repositorios

# Como usuario git
sudo su - git
mkdir -p ~/repositories
cd ~/repositories

Paso 5: Inicializar Repositorio Desnudo

# Crear repositorio desnudo
git init --bare proyecto.git
cd proyecto.git
git config core.sharedRepository group

Paso 6: Configurar Servidor Git

Establecer permisos apropiados:

# Como root
sudo chown -R git:git /home/git/repositories
sudo chmod -R 755 /home/git/repositories

Paso 7: Probar Acceso Remoto

Desde una máquina cliente:

# Clonar el repositorio
git clone git@tu-servidor:repositories/proyecto.git

# Hacer cambios y enviar
cd proyecto
echo "# Mi Proyecto" > README.md
git add README.md
git commit -m "Commit inicial"
git push origin master

Método 2: Instalación de Gitolite

Gitolite proporciona control de acceso avanzado mientras mantiene la simplicidad.

Paso 1: Instalar Gitolite

# Ubuntu/Debian
sudo apt update
sudo apt install -y gitolite3

# CentOS/Rocky Linux
sudo dnf install -y gitolite3

Paso 2: Configurar Gitolite

# Crear usuario git
sudo adduser git

# Copiar clave SSH de admin
sudo cp /ruta/a/clave-admin.pub /tmp/admin.pub
sudo chmod 644 /tmp/admin.pub

# Inicializar gitolite
sudo su - git
gitolite setup -pk /tmp/admin.pub

Paso 3: Clonar Repositorio Admin

Desde tu máquina local:

git clone git@tu-servidor:gitolite-admin
cd gitolite-admin

Paso 4: Configurar Control de Acceso

Editar conf/gitolite.conf:

# gitolite.conf
@desarrolladores = alicia bob carlos
@admins = admin

repo gitolite-admin
    RW+ = @admins

repo proyecto1
    RW+ = @admins
    RW = @desarrolladores

repo proyecto2
    RW+ = @admins
    R = @desarrolladores

Confirmar y enviar cambios:

git add conf/gitolite.conf
git commit -m "Configurar acceso al repositorio"
git push origin master

Método 3: Instalación de Gitea

Gitea proporciona un servicio Git ligero y auto-hospedado con interfaz web.

Paso 1: Instalar Dependencias

# Ubuntu/Debian
sudo apt update
sudo apt install -y git wget sqlite3

# CentOS/Rocky Linux
sudo dnf install -y git wget sqlite

Paso 2: Crear Usuario Gitea

sudo adduser --system --shell /bin/bash --group --disabled-password --home /home/git git

Paso 3: Descargar Gitea

# Verificar última versión en https://github.com/go-gitea/gitea/releases
wget -O /tmp/gitea https://dl.gitea.io/gitea/1.21.0/gitea-1.21.0-linux-amd64
sudo mv /tmp/gitea /usr/local/bin/gitea
sudo chmod +x /usr/local/bin/gitea

Paso 4: Crear Estructura de Directorios

sudo mkdir -p /var/lib/gitea/{custom,data,log}
sudo chown -R git:git /var/lib/gitea
sudo chmod -R 750 /var/lib/gitea

sudo mkdir /etc/gitea
sudo chown root:git /etc/gitea
sudo chmod 770 /etc/gitea

Paso 5: Crear Servicio Systemd

Crear /etc/systemd/system/gitea.service:

[Unit]
Description=Gitea (Git with a cup of tea)
After=syslog.target
After=network.target

[Service]
RestartSec=2s
Type=simple
User=git
Group=git
WorkingDirectory=/var/lib/gitea/
ExecStart=/usr/local/bin/gitea web --config /etc/gitea/app.ini
Restart=always
Environment=USER=git HOME=/home/git GITEA_WORK_DIR=/var/lib/gitea

[Install]
WantedBy=multi-user.target

Paso 6: Iniciar Gitea

sudo systemctl daemon-reload
sudo systemctl enable gitea
sudo systemctl start gitea
sudo systemctl status gitea

Paso 7: Configurar Firewall

# UFW (Ubuntu/Debian)
sudo ufw allow 3000/tcp

# firewalld (CentOS/Rocky)
sudo firewall-cmd --permanent --add-port=3000/tcp
sudo firewall-cmd --reload

Paso 8: Completar Instalación Web

Acceder a http://tu-servidor:3000 y completar el asistente de instalación.

Método 4: Instalación de GitLab CE

GitLab proporciona una plataforma DevOps completa con alojamiento Git, CI/CD y gestión de proyectos.

Paso 1: Instalar Dependencias

# Ubuntu/Debian
sudo apt update
sudo apt install -y curl openssh-server ca-certificates tzdata perl

# CentOS/Rocky Linux
sudo dnf install -y curl policycoreutils openssh-server perl
sudo systemctl enable sshd
sudo systemctl start sshd

Paso 2: Agregar Repositorio GitLab

# Ubuntu/Debian
curl https://packages.gitlab.com/install/repositories/gitlab/gitlab-ce/script.deb.sh | sudo bash

# CentOS/Rocky Linux
curl https://packages.gitlab.com/install/repositories/gitlab/gitlab-ce/script.rpm.sh | sudo bash

Paso 3: Instalar GitLab

# Ubuntu/Debian
sudo EXTERNAL_URL="https://gitlab.tudominio.com" apt install -y gitlab-ce

# CentOS/Rocky Linux
sudo EXTERNAL_URL="https://gitlab.tudominio.com" dnf install -y gitlab-ce

Paso 4: Configurar GitLab

Editar /etc/gitlab/gitlab.rb:

external_url 'https://gitlab.tudominio.com'
gitlab_rails['gitlab_shell_ssh_port'] = 22
gitlab_rails['time_zone'] = 'UTC'

Reconfigurar GitLab:

sudo gitlab-ctl reconfigure

Paso 5: Acceder a GitLab

Acceder a https://gitlab.tudominio.com y establecer la contraseña de root.

Configuración

Configuración del Servidor SSH

Optimizar SSH para operaciones Git editando /etc/ssh/sshd_config:

# Configuración de seguridad
PermitRootLogin no
PubkeyAuthentication yes
PasswordAuthentication no
PermitEmptyPasswords no

# Configuración de rendimiento
ClientAliveInterval 120
ClientAliveCountMax 3
MaxStartups 10:30:100

# Específico de Git
AllowUsers git

Reiniciar SSH:

sudo systemctl restart sshd

Proxy Inverso Nginx para Gitea

Crear /etc/nginx/sites-available/gitea:

server {
    listen 80;
    server_name git.tudominio.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name git.tudominio.com;

    ssl_certificate /etc/letsencrypt/live/git.tudominio.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/git.tudominio.com/privkey.pem;

    location / {
        proxy_pass http://localhost:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Habilitar configuración:

sudo ln -s /etc/nginx/sites-available/gitea /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl reload nginx

Configuración de Base de Datos para Gitea

Para uso en producción, configurar PostgreSQL en lugar de SQLite.

Instalar PostgreSQL

# Ubuntu/Debian
sudo apt install -y postgresql postgresql-contrib

# CentOS/Rocky Linux
sudo dnf install -y postgresql-server postgresql-contrib
sudo postgresql-setup --initdb
sudo systemctl enable postgresql
sudo systemctl start postgresql

Crear Base de Datos

sudo -u postgres psql

CREATE DATABASE gitea;
CREATE USER gitea WITH PASSWORD 'contraseña_segura';
GRANT ALL PRIVILEGES ON DATABASE gitea TO gitea;
\q

Actualizar Configuración de Gitea

Editar /etc/gitea/app.ini:

[database]
DB_TYPE = postgres
HOST = 127.0.0.1:5432
NAME = gitea
USER = gitea
PASSWD = contraseña_segura

Reiniciar Gitea:

sudo systemctl restart gitea

Configuración de Respaldo

Script de Respaldo Automatizado

Crear /usr/local/bin/git-backup.sh:

#!/bin/bash

BACKUP_DIR="/backup/git"
DATE=$(date +%Y%m%d_%H%M%S)
RETENTION_DAYS=30

# Crear directorio de respaldo
mkdir -p "$BACKUP_DIR"

# Respaldar repositorios (servidor Git básico)
tar -czf "$BACKUP_DIR/repositories_$DATE.tar.gz" /home/git/repositories

# Respaldar Gitea (si se usa)
if systemctl is-active --quiet gitea; then
    sudo -u git gitea dump -c /etc/gitea/app.ini -f "$BACKUP_DIR/gitea_$DATE.zip"
fi

# Eliminar respaldos antiguos
find "$BACKUP_DIR" -type f -mtime +$RETENTION_DAYS -delete

echo "Respaldo completado: $DATE"

Hacer ejecutable:

sudo chmod +x /usr/local/bin/git-backup.sh

Programar con Cron

sudo crontab -e

# Agregar respaldo diario a las 2 AM
0 2 * * * /usr/local/bin/git-backup.sh >> /var/log/git-backup.log 2>&1

Ejemplos Prácticos

Ejemplo 1: Crear y Clonar Repositorio

Lado del servidor:

# Servidor SSH Git
sudo su - git
cd ~/repositories
git init --bare miproyecto.git

# Gitea/GitLab: Usar interfaz web

Lado del cliente:

# Servidor SSH
git clone git@tu-servidor:repositories/miproyecto.git

# Gitea
git clone https://git.tudominio.com/usuario/miproyecto.git

# GitLab
git clone https://gitlab.tudominio.com/usuario/miproyecto.git

Ejemplo 2: Gestionar Múltiples Usuarios (Gitolite)

# Clonar repositorio admin
git clone git@tu-servidor:gitolite-admin
cd gitolite-admin

# Agregar clave SSH de usuario
cp ~/Downloads/clave-usuario.pub keydir/users/nuevousuario.pub

# Otorgar acceso al repositorio
cat >> conf/gitolite.conf << EOF

repo nuevoproyecto
    RW+ = admin
    RW = nuevousuario
EOF

# Aplicar cambios
git add keydir/users/nuevousuario.pub conf/gitolite.conf
git commit -m "Agregar nuevousuario con acceso a nuevoproyecto"
git push origin master

Ejemplo 3: Configurar Git Hooks

Hook pre-receive para verificaciones de calidad de código:

Crear repositories/proyecto.git/hooks/pre-receive:

#!/bin/bash

while read oldrev newrev refname; do
    # Verificar formato de mensaje de commit
    if ! git log --format=%s $oldrev..$newrev | grep -qE '^(feat|fix|docs|style|refactor|test|chore):'; then
        echo "Error: Los mensajes de commit deben seguir el formato de commits convencionales"
        exit 1
    fi
done

exit 0

Hacer ejecutable:

chmod +x repositories/proyecto.git/hooks/pre-receive

Ejemplo 4: Reflejar Repositorio Externo

# Crear repositorio espejo
cd /home/git/repositories
git clone --mirror https://github.com/usuario/proyecto.git

# Configurar sincronización automática
cat > /usr/local/bin/sync-mirror.sh << 'EOF'
#!/bin/bash
cd /home/git/repositories/proyecto.git
git fetch --all --prune
EOF

chmod +x /usr/local/bin/sync-mirror.sh

# Programar sincronización cada hora
echo "0 * * * * /usr/local/bin/sync-mirror.sh" | sudo -u git crontab -

Ejemplo 5: Migración de Repositorio

De GitHub a servidor privado:

# Clonar con todas las ramas y etiquetas
git clone --mirror https://github.com/usuario/proyecto.git

# Crear nuevo repositorio en servidor privado
ssh git@tu-servidor "cd repositories && git init --bare proyecto.git"

# Enviar al servidor privado
cd proyecto.git
git push --mirror git@tu-servidor:repositories/proyecto.git

# Actualizar clon local para usar nuevo remoto
cd /ruta/al/clon/local
git remote set-url origin git@tu-servidor:repositories/proyecto.git

Verificación

Probar Conectividad SSH

# Probar conexión SSH
ssh -T git@tu-servidor

# Salida esperada para servidor Git básico:
# PTY allocation request failed on channel 0

# Salida esperada para Gitolite:
# hello usuario, this is git@server running gitolite3...

Verificación de Acceso al Repositorio

# Prueba de clonación
git clone git@tu-servidor:repositories/test.git test-clone

# Prueba de envío
cd test-clone
echo "prueba" > test.txt
git add test.txt
git commit -m "Commit de prueba"
git push origin master

Verificaciones de Estado del Servicio

# Verificar Gitea
sudo systemctl status gitea
curl http://localhost:3000

# Verificar GitLab
sudo gitlab-ctl status
curl http://localhost

# Verificar SSH
sudo systemctl status sshd
ss -tlnp | grep :22

Pruebas de Rendimiento

# Prueba de rendimiento de clonación
time git clone git@tu-servidor:repositories/repo-grande.git

# Prueba de rendimiento de envío
cd repo-grande
dd if=/dev/zero of=archivogrande bs=1M count=100
git add archivogrande
time git commit -m "Agregar archivo grande"
time git push origin master

Solución de Problemas

Problema 1: Permiso Denegado (publickey)

Síntoma: Permission denied (publickey) al intentar clonar o enviar

Solución:

# Verificar que la clave SSH esté agregada
ssh-add -l

# Agregar clave SSH si falta
ssh-add ~/.ssh/id_ed25519

# Probar conexión SSH con salida detallada
ssh -vT git@tu-servidor

# Verificar authorized_keys en el servidor
sudo cat /home/git/.ssh/authorized_keys

# Verificar permisos
sudo ls -la /home/git/.ssh
# Debe mostrar: drwx------ para directorio .ssh
# Debe mostrar: -rw------- para archivo authorized_keys

# Corregir permisos si es necesario
sudo chmod 700 /home/git/.ssh
sudo chmod 600 /home/git/.ssh/authorized_keys
sudo chown -R git:git /home/git/.ssh

Problema 2: Repositorio No Encontrado

Síntoma: Error fatal: repository not found

Solución:

# Verificar que el repositorio exista en el servidor
sudo ls -la /home/git/repositories/

# Verificar ruta del repositorio en comando de clonación
# Correcto: git clone git@servidor:repositories/proyecto.git
# Incorrecto: git clone git@servidor:proyecto.git

# Verificar que el usuario git pueda acceder al repositorio
sudo -u git ls -la /home/git/repositories/proyecto.git

Problema 3: Envío Rechazado

Síntoma: ! [remote rejected] master -> master (pre-receive hook declined)

Solución:

# Verificar permisos del hook
sudo ls -la /home/git/repositories/proyecto.git/hooks/

# Los hooks deben ser ejecutables
sudo chmod +x /home/git/repositories/proyecto.git/hooks/pre-receive

# Verificar salida del hook para errores
sudo -u git /home/git/repositories/proyecto.git/hooks/pre-receive

# Deshabilitar temporalmente el hook para pruebas
sudo mv /home/git/repositories/proyecto.git/hooks/pre-receive \
         /home/git/repositories/proyecto.git/hooks/pre-receive.disabled

Problema 4: Interfaz Web de Gitea No Accesible

Síntoma: No se puede acceder a la interfaz web de Gitea

Solución:

# Verificar estado del servicio Gitea
sudo systemctl status gitea

# Verificar si el puerto está escuchando
sudo ss -tlnp | grep 3000

# Verificar registros de Gitea
sudo journalctl -u gitea -n 50

# Verificar reglas de firewall
sudo ufw status | grep 3000
# O para firewalld:
sudo firewall-cmd --list-ports

# Probar acceso local
curl http://localhost:3000

Problema 5: Operaciones Git Lentas

Síntoma: Las operaciones de clonación y envío son extremadamente lentas

Solución:

# Habilitar repack de Git
cd /home/git/repositories/proyecto.git
sudo -u git git repack -ad

# Habilitar recolección de basura
sudo -u git git gc --aggressive

# Verificar I/O del disco
iostat -x 1 5

# Verificar memoria disponible
free -h

# Habilitar compresión de Git
git config --global core.compression 9

# Para repositorios grandes, aumentar tamaño del buffer
git config --global http.postBuffer 524288000

Problema 6: Fallo de Conexión a Base de Datos (Gitea)

Síntoma: Gitea falla al iniciar con errores de conexión a la base de datos

Solución:

# Verificar estado de PostgreSQL
sudo systemctl status postgresql

# Verificar que la base de datos exista
sudo -u postgres psql -l | grep gitea

# Probar conexión
sudo -u postgres psql -d gitea -c "SELECT version();"

# Verificar configuración de Gitea
sudo cat /etc/gitea/app.ini | grep -A5 "\[database\]"

# Verificar que PostgreSQL permita conexiones locales
sudo grep "local.*all.*all" /etc/postgresql/*/main/pg_hba.conf

# Reiniciar servicios
sudo systemctl restart postgresql
sudo systemctl restart gitea

Mejores Prácticas

Mejores Prácticas de Seguridad

  1. Deshabilitar Autenticación por Contraseña: Siempre usar claves SSH
# /etc/ssh/sshd_config
PasswordAuthentication no
ChallengeResponseAuthentication no
  1. Implementar Fail2ban: Proteger contra ataques de fuerza bruta
sudo apt install fail2ban
sudo systemctl enable fail2ban
sudo systemctl start fail2ban
  1. Actualizaciones de Seguridad Regulares:
# Ubuntu/Debian
sudo apt update && sudo apt upgrade -y

# CentOS/Rocky Linux
sudo dnf update -y
  1. Usar HTTPS para Interfaces Web: Siempre configurar SSL/TLS
# Let's Encrypt
sudo certbot --nginx -d git.tudominio.com

  1. Implementar Control de Acceso: Usar roles de Gitolite o GitLab para permisos granulares

  2. Habilitar Autenticación de Dos Factores: Para interfaces web de Gitea/GitLab

  3. Restringir Shell del Usuario Git:

# Limitar usuario git solo a operaciones Git
sudo usermod -s /usr/bin/git-shell git

Mejores Prácticas de Respaldo

  1. Respaldos Diarios Automatizados: Programar respaldos regulares con cron

  2. Almacenamiento Externo: Almacenar respaldos en ubicación remota

# Sincronizar con servidor remoto
rsync -avz /backup/git/ servidor-remoto:/backup/git/
  1. Probar Procedimientos de Restauración: Verificar regularmente que los respaldos sean recuperables
# Probar restauración
mkdir /tmp/prueba-restauracion
tar -xzf /backup/git/repositories_20240101.tar.gz -C /tmp/prueba-restauracion

  1. Retención de Versiones: Mantener múltiples versiones de respaldo (diarias, semanales, mensuales)

  2. Documentar Proceso de Recuperación: Mantener documentación clara de restauración

Mejores Prácticas de Rendimiento

  1. Mantenimiento de Repositorios: Recolección de basura y reempaquetado regular
# Crear script de mantenimiento
#!/bin/bash
for repo in /home/git/repositories/*.git; do
    cd "$repo"
    git gc --aggressive --prune=now
    git repack -ad
done
  1. Habilitar Caché: Para servidores Git basados en web
# Configuración de caché de Nginx
proxy_cache_path /var/cache/nginx levels=1:2 keys_zone=gitea_cache:10m max_size=1g;

location / {
    proxy_cache gitea_cache;
    proxy_cache_valid 200 10m;
    proxy_pass http://localhost:3000;
}
  1. Monitoreo de Recursos: Monitorear uso de CPU, memoria y disco
# Instalar herramientas de monitoreo
sudo apt install htop iotop nethogs
  1. Optimizar Base de Datos: Para Gitea/GitLab con backends de base de datos
-- Optimización de PostgreSQL
VACUUM ANALYZE;
REINDEX DATABASE gitea;
  1. Almacenamiento SSD: Usar SSDs para almacenamiento de repositorios cuando sea posible

Mejores Prácticas de Colaboración

  1. Flujos de Trabajo Estandarizados: Documentar flujos de trabajo Git para el equipo

  2. Protección de Ramas: Implementar reglas de protección de ramas

  3. Proceso de Revisión de Código: Usar merge/pull requests para todos los cambios

  4. Estándares de Mensajes de Commit: Aplicar mensajes de commit convencionales con hooks

  5. Documentación: Mantener documentación completa del repositorio

Mejores Prácticas Operacionales

  1. Monitoreo y Alertas: Configurar monitoreo de servicios
# Script de monitoreo de ejemplo
#!/bin/bash
if ! systemctl is-active --quiet gitea; then
    echo "¡Gitea está caído!" | mail -s "Alerta: Gitea Caído" [email protected]
fi
  1. Rotación de Registros: Configurar rotación de registros apropiada
# /etc/logrotate.d/gitea
/var/log/gitea/*.log {
    daily
    rotate 14
    compress
    delaycompress
    notifempty
    create 640 git git
    sharedscripts
    postrotate
        systemctl reload gitea
    endscript
}

  1. Planificación de Capacidad: Monitorear crecimiento y planificar recursos en consecuencia

  2. Estrategia de Actualización: Probar actualizaciones en staging antes de producción

  3. Plan de Recuperación ante Desastres: Documentar y probar procedimientos de recuperación ante desastres

Conclusión

Configurar un servidor Git privado proporciona control completo sobre tu infraestructura de gestión de código fuente, ofreciendo flexibilidad, seguridad y ahorro de costos. Ya sea que elijas una solución simple basada en SSH para proyectos personales, Gitolite para control de acceso avanzado, o plataformas completas como Gitea o GitLab para colaboración en equipo, esta guía ha proporcionado instrucciones completas para la implementación.

La clave para una gestión exitosa del servidor Git radica en elegir la solución correcta para tus necesidades, implementar medidas de seguridad apropiadas, mantener respaldos regulares y seguir las mejores prácticas operacionales. Comienza con una configuración simple y escala la complejidad a medida que crecen tus requisitos.

Tu inversión en servidor Git privado rinde dividendos a través de seguridad mejorada, control completo de datos y la flexibilidad de personalizar tu infraestructura de desarrollo exactamente según sea necesario. Siguiendo las recomendaciones de esta guía, has establecido una base sólida para un control de versiones confiable y seguro que servirá a tus necesidades de desarrollo durante años.

Recuerda que la administración del servidor Git es una responsabilidad continua que requiere mantenimiento regular, monitoreo y actualizaciones. Mantente al día con los parches de seguridad, monitorea las métricas de rendimiento, prueba tus procedimientos de respaldo y refina continuamente tus flujos de trabajo para mantener una infraestructura Git saludable y eficiente.

Con tu servidor Git privado correctamente configurado y mantenido, puedes enfocarte en lo que más importa: escribir excelente código y construir productos de software excepcionales con confianza en tu base de control de versiones.