Instalar y configurar Gogs en CentOS 7 con PostgreSQL y Nginx

Gogs es un servicio Git ligero escrito en Go. En esta guía paso a paso instalas EPEL, PostgreSQL, Go, Gogs y Nginx en CentOS 7. Al final tendrás Gogs corriendo como servicio bajo systemd y Nginx actuando como proxy inverso.

Importante: Gogs = servidor Git autoalojado en Go. PostgreSQL = base de datos relacional. Nginx = servidor web y proxy inverso.

Introducción breve

Gogs es software libre y de código abierto para hospedar repositorios Git. Ocupa pocos recursos y su interfaz web recuerda a GitHub. Soporta MySQL, PostgreSQL, SQLite3, MSSQL y TiDB. Aquí usaremos PostgreSQL y Nginx como proxy inverso.

Audiencia: administradores de sistemas y desarrolladores que quieran un servidor Git autogestionado en CentOS 7.

Requisitos básicos

• Servidor CentOS 7 con acceso root.
• Conexión a Internet para descargar paquetes.
• Privilegios sudo o acceso root.

Resumen de pasos

1. Instalar repositorio EPEL
2. Instalar y configurar PostgreSQL
3. Instalar Go y Git
4. Descargar y compilar Gogs
5. Configurar Gogs
6. Ejecutar Gogs como servicio systemd
7. Configurar Nginx como proxy inverso
8. Probar la instalación

Fact box: puertos clave

• PostgreSQL: 5432 (localhost en esta guía)
• Gogs: 3000 por defecto (escucha en 127.0.0.1)
• HTTP: 80 (Nginx)

Definiciones en una línea

• Gogs: servidor Git ligero y autohospedado escrito en Go.
• PostgreSQL: base de datos relacional robusta y abierta.
• Nginx: servidor web y proxy reverso eficiente.
• systemd: gestor de servicios en CentOS 7.

Paso 1 - Instalar el repositorio EPEL

Primero añadimos EPEL (repositorio Extra Packages for Enterprise Linux) para acceder a paquetes adicionales.

sudo yum -y install epel-release

EPEL ya está agregado al sistema CentOS 7.

Paso 2 - Instalar y configurar PostgreSQL

Gogs soporta varias bases de datos. Aquí usamos PostgreSQL.

Instala PostgreSQL:

sudo yum -y install postgresql-server postgresql-contrib

Inicializa la base de datos:

sudo postgresql-setup initdb

Edita la configuración para que PostgreSQL escuche solo en localhost y habilite md5 para conexiones locales.

Cambia al usuario postgres:

su - postgres

Entra en el directorio de datos y edita postgresql.conf:

cd data/
vim postgresql.conf

Descomenta y ajusta:

listen_addresses = '127.0.0.1'

Guarda y edita pg_hba.conf para usar md5 en la línea local (127.0.0.1/32):

vim pg_hba.conf

Asegúrate de tener esta línea:

host    all             all             127.0.0.1/32            md5

Arranca y habilita PostgreSQL:

sudo systemctl start postgresql
sudo systemctl enable postgresql

Comprueba que PostgreSQL esté escuchando:

netstat -plntu

Deberías ver el puerto 5432 en 127.0.0.1.

Crear la base de datos y el usuario para Gogs

Ingresa al shell de psql como postgres:

su - postgres
psql

Crea el usuario git y permite crear bases de datos:

CREATE USER git CREATEDB;
\password git

Crea la base de datos gogs_production y asigna al usuario git:

CREATE DATABASE gogs_production OWNER git;
exit

Paso 3 - Instalar Go y Git

Instala git desde los repositorios:

sudo yum -y install git

Crea el usuario del sistema para alojar Gogs y sus repositorios:

useradd -m -s /bin/bash git
passwd git

Inicia sesión como git y crea el directorio local donde colocaremos Go y descargas:

su - git
mkdir -p /home/git/local

Descarga la versión de Go adecuada. En el ejemplo original se usa go1.9.2; revisa la web oficial para la versión actual. En este tutorial reproducimos el comando usado:

cd ~/local
wget https://dl.google.com/go/go1.9.2.linux-amd64.tar.gz

Extrae y limpia el tar:

tar -xf go1.9.2.linux-amd64.tar.gz
rm -f go1.9.2.linux-amd64.tar.gz

Configura las variables de entorno para Go (GOROOT y GOPATH) en el .bashrc del usuario git:

cd ~/
echo 'export GOROOT=$HOME/local/go' >> $HOME/.bashrc
echo 'export GOPATH=$HOME/go' >> $HOME/.bashrc
echo 'export PATH=$PATH:$GOROOT/bin:$GOPATH/bin' >> $HOME/.bashrc

Recarga el shell:

source ~/.bashrc

Asegúrate de usar bash como shell predeterminado y comprueba la versión de Go:

go version

Go está instalado para el usuario git.

Paso 4 - Instalar Gogs (compilar desde el código fuente)

Como usuario git, descarga Gogs desde GitHub usando go get:

su - git
go get -u github.com/gogits/gogs

El código se descarga en $GOPATH/src/github.com/gogits/gogs. Compílalo:

cd $GOPATH/src/github.com/gogits/gogs
go build

Si no hay errores, ejecuta Gogs en modo web:

./gogs web

Gogs arranca en la IP pública por defecto en el puerto 3000 (para pruebas). Visita http://TU_IP:3000/ en un navegador.

Ejemplo de acceso:

http://192.168.33.10:3000/

Presiona Ctrl+C en la terminal para detener Gogs antes de continuar con la configuración permanente.

Paso 5 - Configurar Gogs

Crea un directorio custom para configuraciones y copia el archivo app.ini de ejemplo:

cd $GOPATH/src/github.com/gogits/gogs
mkdir -p custom/conf/
cp conf/app.ini custom/conf/app.ini
vim custom/conf/app.ini

Ajusta la sección [server] para forzar Gogs a escuchar solo en localhost (buena práctica con proxy inverso):

[server]
 PROTOCOL = http
 DOMAIN = localhost
 ROOT_URL = %(PROTOCOL)s://%(DOMAIN)s:%(HTTP_PORT)s/
 HTTP_ADDR = 127.0.0.1
 HTTP_PORT = 3000

En la sección [database] configura tus credenciales de PostgreSQL:

[database]
 DB_TYPE = postgres
 HOST = 127.0.0.1:5432
 NAME = gogs_production
 USER = git
 PASSWD = aqwe123@

Guarda y arranca Gogs para verificar la configuración:

./gogs web

Gogs ahora corre como servicio web accesible en 127.0.0.1:3000.

Notas: reemplaza PASSWD por una contraseña segura y, preferiblemente, administra credenciales con un gestor o variables seguras en producción.

Paso 6 - Ejecutar Gogs como servicio en CentOS 7 (systemd)

Crea la unidad systemd para ejecutar Gogs como servicio. Crea /etc/systemd/system/gogs.service:

cd /etc/systemd/system
vim gogs.service

Pega la siguiente configuración (ajusta WorkingDirectory y ExecStart según tu GOPATH):

[Unit]
 Description=Gogs
 After=syslog.target
 After=network.target
 After=mariadb.service mysqld.service postgresql.service memcached.service redis.service
  
 [Service]
 # Modify these two values and uncomment them if you have
 # repos with lots of files and get an HTTP error 500 because
 # of that
 ###
 #LimitMEMLOCK=infinity
 #LimitNOFILE=65535
 Type=simple
 User=git
 Group=git
 WorkingDirectory=/home/git/go/src/github.com/gogits/gogs
 ExecStart=/home/git/go/src/github.com/gogits/gogs/gogs web
 Restart=always
 Environment=USER=git HOME=/home/git
  
 [Install]
 WantedBy=multi-user.target

Recarga systemd e inicia el servicio:

systemctl daemon-reload
systemctl start gogs
systemctl enable gogs

Comprueba estado y puertos:

netstat -plntu
systemctl status gogs

Consejo: usa journalctl -u gogs -f para seguir logs en tiempo real.

Paso 7 - Instalar y configurar Nginx como proxy inverso para Gogs

Instala Nginx desde EPEL:

yum -y install nginx

Crea un bloque de servidor para Gogs en /etc/nginx/conf.d/gogs.conf:

cd /etc/nginx/
vim conf.d/gogs.conf

Versión mínima (igual a la original):

server {
    listen 80;
    server_name git.hakase-labs.co;

    location / {
        proxy_pass http://127.0.0.1:3000;
    }
}

Recomendación para producción: añade encabezados proxy y manejo de WebSocket. Ejemplo mejorado:

server {
    listen 80;
    server_name git.hakase-labs.co;

    location / {
        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;
        proxy_pass http://127.0.0.1:3000;
        proxy_read_timeout 120;
        proxy_buffering off;
    }
}

Prueba la configuración de Nginx:

nginx -t

Inicia y habilita Nginx:

systemctl restart nginx
systemctl enable nginx

Comprueba que el puerto 80 esté en escucha:

netstat -plntu

Notas de seguridad adicionales para Nginx y SELinux

• Si SELinux está habilitado, añade el puerto 3000 al tipo http_port_t:

yum -y install policycoreutils-python
semanage port -a -t http_port_t -p tcp 3000

• Abre el puerto 80 en el firewall (firewalld):

firewall-cmd --permanent --add-service=http
firewall-cmd --reload

• Para producción, configura TLS (Let’s Encrypt) y fuerza redirección HTTPS.

Paso 8 - Pruebas finales

Abre en tu navegador la URL pública configurada:

http://git.hakase-labs.co/

En la página de instalación introduce los datos de PostgreSQL (host, puerto, usuario, contraseña, nombre de BD). Luego expande “Admin account settings” y crea el usuario administrador.

Rellena usuario admin, contraseña y correo:

Haz clic en “Install Gogs”. Serás redirigido al Dashboard de usuario.

Panel de administración:

Gogs ya está instalado con PostgreSQL y Nginx en CentOS 7.

Lista de verificación rápida (checklist)

• EPEL instalado
• PostgreSQL inicializado y en 127.0.0.1:5432
• Usuario git y base gogs_production creados
• Go y Git instalados para el usuario git
• Gogs compilado y configurado en custom/conf/app.ini
• Servicio systemd gogs activo y habilitado
• Nginx instalado y proxy configurado
• Firewall y SELinux ajustados (si aplica)
• Instalación final probada en el navegador

Playbook breve: desplegar Gogs (resumen operativo)

1. Preparar servidor: actualizar paquetes y añadir EPEL.
2. Instalar PostgreSQL y crear usuario/BD para Gogs.
3. Crear usuario git y preparar entorno Go.
4. Descargar y compilar Gogs en $GOPATH.
5. Configurar custom/conf/app.ini con DB y server (HTTP_ADDR=127.0.0.1).
6. Crear unidad systemd gogs.service y habilitar.
7. Instalar Nginx y crear conf.d/gogs.conf con proxy_pass a 127.0.0.1:3000.
8. Ajustar firewall/SELinux y obtener certificado TLS (opcional).
9. Acceder a la URL y completar la pantalla de instalación.

Operaciones: crear backup y rollback (sencillo)

Backup rápido

• Repositorios: copia /home/git/gogs-repositories (o la ruta configurada) con rsync.
• Base de datos: volcar PostgreSQL:

pg_dump -U git -h 127.0.0.1 gogs_production > gogs_production.sql

Rollback básico

1. Detén el servicio Gogs: systemctl stop gogs
2. Restaura los repositorios desde la copia.
3. Restaura la BD si es necesario: psql -U git -d gogs_production < gogs_production.sql
4. Inicia Gogs: systemctl start gogs

Seguridad y buenas prácticas

• No expongas Gogs directamente en Internet en el puerto 3000. Usa proxy inverso (Nginx).
• Habilita HTTPS con certificados válidos.
• Usa contraseñas fuertes para la BD y el administrador.
• Restringe PostgreSQL a localhost si Nginx/Gogs corren en la misma máquina.
• Aplica actualizaciones periódicas y revisa CVE relevantes.

Alternativas y cuándo elegirlas

• Si prefieres contenedores: usa la imagen oficial de Gogs en Docker. Es más fácil de aislar y actualizar.
• Si quieres más características empresariales: valora Gitea (fork comunitario) o GitLab (más pesado).
• Para kioscos someros o pruebas: SQLite es más simple, pero no es ideal en grandes instalaciones.

Solución de problemas común

• Gogs no arranca: revisa journalctl -u gogs y logs en custom/log.
• Error de conexión a PostgreSQL: verifica pg_hba.conf, que postgresql esté en 127.0.0.1, y que las credenciales sean correctas.
• Nginx devuelve 502/504: confirma que Gogs está escuchando en 127.0.0.1:3000 y que SELinux no bloquea el puerto.
• Problemas con websockets (hooks/SSH web UI): agrega proxy_set_header y proxy_buffering off en Nginx.

Roles y tareas (checklist por rol)

Administrador de sistemas

• Instalar EPEL y paquetes.
• Configurar PostgreSQL y SELinux/firewall.
• Crear unit systemd y configurar usuario git.

Desarrollador / propietario del proyecto

• Crear cuentas y repositorios en Gogs.
• Configurar acceso SSH (claves públicas) en perfiles.
• Revisar integraciones y webhooks.

Operaciones / Seguridad

• Habilitar TLS y renovar certificados.
• Auditar accesos y backups periódicos.

Diagrama de decisión (flujo básico)

flowchart TD
  A[¿Necesito autoalojar Git?] -->|Sí| B[Elegir solución]
  B --> C{Requisitos}
  C -->|Ligero, fácil| D[Gogs]
  C -->|Contenedores| E[Docker + Gogs]
  C -->|Características avanzadas| F[GitLab]
  D --> G[Implementar en CentOS 7]
  E --> G

Criterios de aceptación (instalación completa)

• Gogs se inicia como servicio systemd y permanece activo tras reinicio.
• Nginx sirve la URL pública en el puerto 80 (o 443 con TLS).
• La instalación web permite completar la configuración usando PostgreSQL.
• Se pueden crear repositorios y realizar push/pull desde un cliente Git.

Referencia

https://gogs.io/docs/installation

Resumen final

Gogs ofrece un servidor Git autohospedado ligero. Siguiendo estos pasos instalas PostgreSQL, Go y Gogs, lo ejecutas como servicio y colocas Nginx como proxy inverso. Aplica las recomendaciones de seguridad (TLS, SELinux, firewall) antes de poner la instancia en producción.