Cómo instalar Gitea Code Hosting usando Docker en Rocky Linux 8

Gitea es un servicio de alojamiento de código autoalojado similar a Github, Bitbucket y Gitlab. Está escrito en lenguaje Go y puede instalarse en múltiples sistemas operativos, incluyendo Linux, macOS, Windows, y arquitecturas como amd64, i386, ARM, y otras. Al ser una aplicación ligera, puede instalarse con unos requisitos mínimos de hardware. Incluye un editor de archivos de repositorio, servidor OpenSSH, seguimiento de incidencias, pull requests, gestión de usuarios, notificaciones, wiki integrada, soporte LFS, ganchos Git y mucho más.

En este artículo, aprenderás a instalar Gitea utilizando Docker en un servidor Rocky Linux 8.

Requisitos previos

• Un servidor que ejecute Rocky Linux 8.5.
• Un usuario no root con privilegios sudo.
• Desactiva SELinux.
• Actualiza todo.

  $ sudo dnf update
  

• Instala los paquetes esenciales.

  $ sudo dnf install yum-utils nano curl
  

• Un nombre de dominio completo (FQDN) que apunte al servidor como gitea.example.com.

Paso 1 – Configurar el cortafuegos

El primer paso es configurar el cortafuegos. Rocky Linux utiliza el cortafuegos Firewalld. Comprueba el estado del cortafuegos.

$ sudo firewall-cmd --state
running

El cortafuegos funciona con diferentes zonas, y la zona pública es la que utilizaremos por defecto. Enumera todos los servicios y puertos activos en el cortafuegos.

$ sudo firewall-cmd --permanent --list-services

Debería mostrar la siguiente salida.

cockpit dhcpv6-client ssh

Permitir puertos HTTP y HTTPS.

$ sudo firewall-cmd --permanent --add-service=http
$ sudo firewall-cmd --permanent --add-service=https

Abre el puerto 2221 para SSH.

$ sudo firewall-cmd --permanent --add-port=2221/tcp

Enumera todos los servicios habilitados por el cortafuegos.

$ sudo firewall-cmd --permanent --list-all

Deberías ver un resultado similar.

public
  target: default
  icmp-block-inversion: no
  interfaces:
  sources:
  services: cockpit dhcpv6-client http https ssh
  ports: 2221/tcp
  protocols:
  forward: no
  masquerade: no
  forward-ports:
  source-ports:
  icmp-blocks:
  rich rules:

Recarga el cortafuegos para activar los cambios.

$ sudo firewall-cmd --reload

Paso 2 – Instala Docker

Rocky Linux incluye una versión antigua de Docker. Para instalar la última versión, instala primero el repositorio oficial de Docker.

$ sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

Instala la última versión de Docker.

$ sudo dnf install docker-ce docker-ce-cli containerd.io

Activa y ejecuta el demonio Docker.

$ sudo systemctl enable docker --now

Comprueba que se está ejecutando.

? docker.service - Docker Application Container Engine
   Loaded: loaded (/usr/lib/systemd/system/docker.service; enabled; vendor preset: disabled)
   Active: active (running) since Sat 2022-04-02 13:26:08 UTC; 2s ago
     Docs: https://docs.docker.com
 Main PID: 21152 (dockerd)
    Tasks: 7
   Memory: 30.9M
   CGroup: /system.slice/docker.service
           ??21152 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
...

Por defecto, Docker requiere privilegios de root. Si quieres evitar utilizar sudo cada vez que ejecutes el comando docker, añade tu nombre de usuario al grupo docker.

$ sudo usermod -aG docker $(whoami)

Tendrás que salir del servidor y volver a entrar como el mismo usuario para activar este cambio.

Paso 3 – Instala Docker Compose

Descarga la última versión estable de Docker Compose.

$ sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Aplica permisos de ejecutable al archivo binario de Docker Compose.

$ sudo chmod +x /usr/local/bin/docker-compose

Prueba la instalación.

$ docker-compose --version
docker-compose version 1.29.2, build 5becea4c

Instala el script Docker-compose Bash Completion.

$ sudo curl \
    -L https://raw.githubusercontent.com/docker/compose/1.29.2/contrib/completion/bash/docker-compose \
    -o /etc/bash_completion.d/docker-compose

Recarga la configuración de tu perfil para que funcione el bash-completion.

$ source ~/.bashrc

Paso 4 – Configurar e instalar Gitea

Configura la zona horaria del sistema

Puedes comprobar la zona horaria actual de tu sistema mediante el siguiente comando.

$ timedatectl
  Local time: Mon 2022-05-02 06:38:36 UTC
           Universal time: Mon 2022-05-02 06:38:36 UTC
                 RTC time: Mon 2022-05-02 06:38:36
                Time zone: Etc/UTC (UTC, +0000)
System clock synchronized: yes
              NTP service: active
          RTC in local TZ: no

Puedes ver que el sistema está configurado en la zona horaria GMT o UTC. Si vives en una zona con una zona horaria diferente o quieres cambiarla, utiliza el siguiente comando para hacerlo.

$ sudo timedatectl set-timezone Asia/Kolkata

Comprueba de nuevo la zona horaria.

$ timedatectl
Local time: Mon 2022-05-02 12:09:23 IST
           Universal time: Mon 2022-05-02 06:39:23 UTC
                 RTC time: Mon 2022-05-02 06:39:22
                Time zone: Asia/Kolkata (IST, +0530)
System clock synchronized: yes
              NTP service: active
          RTC in local TZ: no

Puedes ver que la zona horaria se ha actualizado a IST, que es GMT+5:30.

Crear directorios para Gitea

Crea el directorio para Gitea.

$ mkdir ~/gitea-docker

Cambia al directorio de Gitea.

$ cd ~/gitea-docker

Crea directorios para almacenar los datos de Gitea y las bases de datos PostgreSQL.

$ mkdir {gitea,postgres}

Configura el archivo Docker Compose de Gitea

Obtén los valores UID (Identificador de Usuario) y GID (Identificador de Grupo) del usuario actualmente conectado. El primer comando genera el UID, mientras que el segundo genera el GID. Copia ambos valores, ya que serán necesarios para configurar el archivo Docker Compose.

$ echo $(id -u)
1000
$ echo $(id -g)
1000

Crea y abre el archivo Docker Compose para editarlo.

$ nano docker-compose.yml

Pega en él el siguiente código. Pega los valores UID y GID generados anteriormente.

version: "3"

networks:
  gitea:
    external: false

services:
  server:
    image: gitea/gitea:1.16.6
    container_name: gitea
    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=gitea
    restart: always
    networks:
      - gitea
    volumes:
      - ./gitea:/data
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "3000:3000"
      - "2221:22"
    depends_on:
      - db

  db:
    image: postgres:14
    restart: always
    environment:
      - POSTGRES_USER=gitea
      - POSTGRES_PASSWORD=gitea
      - POSTGRES_DB=gitea
    networks:
      - gitea
    volumes:
      - ./postgres:/var/lib/postgresql/data

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.

El archivo Docker Compose anterior despliega dos contenedores: uno para Gitea y otro para PostgreSQL. Hemos añadido algunas variables de entorno para configurar los detalles de la base de datos. Para conectar la base de datos PostgreSQL al contenedor Gitea, hemos especificado en el archivo el host como nombre del servicio PostgreSQL.

Los parámetros de puerto "3000:3000" y "2221:22" especifican el mapeo de puertos donde el puerto de la izquierda denota el puerto del host y el de la derecha el puerto del contenedor. Gitea utiliza el puerto 3000 para su servicio web, que es el que hemos expuesto también al servidor. Para SSH, nuestro sistema ya utiliza el puerto 22 con fines de registro. Por lo tanto, especificamos un puerto personalizado para realizar operaciones SSH. En nuestro caso, estamos utilizando el puerto 2221. Este puerto también debe abrirse a través de tu cortafuegos, lo que ya hicimos en el paso 1 de este tutorial.

Tanto Gitea como los contenedores PostgreSQL están conectados a través de una red Docker interna común llamada gitea. Los montajes de volumen crearán automáticamente los directorios gitea y postgres en la carpeta actual cuando inicies tu instalación Docker. El ID de usuario especificado en el archivo compose es el que utilizará el contenedor Gitea para crear el directorio gitea. Por otra parte, el contenedor PostgreSQL será gestionado por el usuario systemd-coredump, que es el comportamiento por defecto. Puedes cambiar ese comportamiento, pero no es necesario.

Personaliza tu instalación de Gitea

Puedes personalizar tu instalación de Gitea añadiendo un archivo app.ini al directorio ~/gitea-docker/gitea/gitea/conf. Tras la instalación, este archivo puede editarse desde dentro del contenedor desde la ubicación /data/gitea/conf/app.ini. Puedes utilizar como referencia el archivo ini de ejemplo del repositorio de Github de Gitea.

Instalar Gitea

Ejecuta el siguiente comando para iniciar los contenedores Gitea.

$ docker-compose up -d

Comprueba el estado de los contenedores para asegurarte de que funcionan correctamente.

$ docker ps
CONTAINER ID   IMAGE                COMMAND                  CREATED             STATUS             PORTS                                                                              NAMES
bd06e370c46b   gitea/gitea:1.16.6   "/usr/bin/entrypoint…"   19 minutes ago   Up 19 minutes   0.0.0.0:3000->3000/tcp, :::3000->3000/tcp, 0.0.0.0:2221->22/tcp, :::2221->22/tcp   gitea
3fc6c4bce810   postgres:14          "docker-entrypoint.s…"   19 minutes ago   Up 19 minutes   5432/tcp                                                                           gitea_db_1

También puedes utilizar el siguiente comando para comprobar el estado.

$ docker-compose ps
   Name                 Command               State                                       Ports
------------------------------------------------------------------------------------------------------------------------------------
gitea        /usr/bin/entrypoint /bin/s ...   Up      0.0.0.0:2221->22/tcp,:::2221->22/tcp, 0.0.0.0:3000->3000/tcp,:::3000->3000/tcp
gitea_db_1   docker-entrypoint.sh postgres    Up      5432/tcp

Paso 5 – Instalar SSL

Para instalar un certificado SSL utilizando Let’s Encrypt, necesitamos instalar la herramienta Certbot.

En primer lugar, necesitas descargar e instalar el repositorio EPEL.

$ sudo dnf install epel-release

Ejecuta los siguientes comandos para instalar Certbot.

$ sudo dnf install certbot

Generar el certificado SSL.

$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d gitea.example.com

El comando anterior descargará un certificado en el directorio /etc/letsencrypt/live/gitea.example.com de tu servidor.

Genera un certificado de grupo Diffie-Hellman.

$ sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 4096

Crea un directorio raíz web de desafío para la renovación automática de Let’s Encrypt.

$ sudo mkdir -p /var/lib/letsencrypt

Crea un Cron Job para renovar el SSL. Se ejecutará cada día para comprobar el certificado y renovarlo si es necesario. Para ello, primero, crea el archivo /etc/cron.daily/certbot-renew y ábrelo para editarlo.

$ sudo nano /etc/cron.daily/certbot-renew

Pega el siguiente código.

#!/bin/sh
certbot renew --cert-name gitea.example.com --webroot -w /var/lib/letsencrypt/ --post-hook "systemctl reload nginx"

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando te lo pida.

Cambia los permisos del archivo de la tarea para que sea ejecutable.

$ sudo chmod +x /etc/cron.daily/certbot-renew

Paso 6 – Instalar Nginx

Vamos a instalar la última versión de Nginx. Crea y abre el archivo /etc/yum.repos.d/nginx.repo para editarlo.

$ sudo nano /etc/yum.repos.d/nginx.repo

Pega en él las siguientes líneas.

[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

[nginx-mainline]
name=nginx mainline repo
baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
gpgcheck=1
enabled=0
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida.

Instala Nginx.

$ sudo dnf install nginx

Verifica la instalación.

$ nginx -v
nginx version: nginx/1.20.2

Activa e inicia el servicio Nginx.

$ sudo systemctl enable nginx --now

Crea y abre el archivo /etc/nginx/conf.d/gitea.conf para editarlo.

$ sudo nano /etc/nginx/conf.d/gitea.conf

Pega en él el siguiente código.

# Redirect all non-encrypted to encrypted
server {
    listen 80;
    listen [::]:80;
    server_name gitea.example.com;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    
    server_name gitea.example.com;

    ssl_certificate     /etc/letsencrypt/live/gitea.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/gitea.example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/gitea.example.com/chain.pem;
    ssl_session_timeout 1d;
    ssl_session_cache shared:MozSSL:10m;
    ssl_session_tickets off;
    ssl_stapling on;
    ssl_stapling_verify on;
    ssl_dhparam /etc/ssl/certs/dhparam.pem;
    
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;

    access_log /var/log/nginx/gitea.example.com.access.log main;
    error_log  /var/log/nginx/gitea.example.com.error.log;

    location / {
        client_max_body_size 100M;
        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;
    }
}

Una vez terminado, guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida. La configuración anterior permite a Nginx actuar como servidor proxy y enlazarse al puerto 3000 en localhost. Para permitir la carga de archivos grandes para Git LFS, puedes cambiar el valor de la variable client_max_body_size según tus necesidades. Para nuestro tutorial, estamos utilizando 100 MB como límite.

Abre el archivo /etc/nginx/nginx.conf para editarlo.

$ sudo nano /etc/nginx/nginx.conf

Añade la siguiente línea antes de la línea include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.

Verifica la sintaxis del archivo de configuración de Nginx.

$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Reinicia el servicio Nginx para habilitar la nueva configuración.

$ sudo systemctl restart nginx

Paso 7 – Acceder y configurar Gitea

Visita la URL https://gitea.example.com en tu navegador, y aparecerá la siguiente pantalla de instalación.

La mayoría de los campos se rellenarán previamente basándose en los valores del archivo Docker compose.

Introduce gitea.example.com como Dominio del Servidor y https://gitea.example.com como URL Base de Gitea. Cambia el valor del Puerto del Servidor SSH de 22 a 2221. Deja el resto de ajustes como están.

Si quieres utilizar las funciones de correo, puedes añadir los datos de tu servidor SMTP. Despliega la sección Configuración de correo electrónico de la página e introduce los valores como se muestra en la captura de pantalla. Asegúrate de incluir tu puerto SMTP con el nombre de host como se muestra. Para nuestro tutorial, estamos utilizando el servicio Amazon SES. Puedes utilizar cualquier servicio SMTP de tu elección.

Hay algunos ajustes más que deberías comprobar antes de instalar. Para cambiarlos, despliega la sección Configuración del servidor y del servicio de terceros de la página.

Cambia los ajustes según tus necesidades. Hemos activado la opción Ocultar direcciones de correo electrónico por defecto para garantizar una mayor privacidad. Si no quieres que la gente registre una cuenta, activa la opción Desactivar autorregistro.

Por último, pero no por ello menos importante, configura tu cuenta de administrador. Despliega la sección Configuración de la cuenta de administrador de la página y rellena los valores necesarios.

Haz clic en el botón Instalar Gitea cuando hayas terminado para completar la instalación. Se te redirigirá al panel de control de Gitea. Si, por alguna razón, obtienes un error 502, actualiza la página.

Paso 8 – Crear el primer repositorio

Vamos a crear nuestro primer repositorio. Para ello, haz clic en el signo + del panel de control.

Introduce los detalles del repositorio. Selecciona la etiqueta Emisión por defecto eligiéndola en el menú desplegable. Selecciona una licencia adecuada para tu repositorio.

Selecciona la rama por defecto para tu repositorio.

Una vez satisfecho, haz clic en el botón Crear repositorio para crear tu primer repositorio en tu instalación de Gitea. Serás redirigido a la página de inicio de tu repositorio.

Paso 9 – Configurar SSH

Vamos a configurar SSH para utilizarlo con nuestro recién creado repositorio.

Para nuestro tutorial, utilizaremos un PC local con Ubuntu preinstalado. Sin embargo, los comandos deberían funcionar en el terminal de cualquier SO sin muchos cambios.

Crea una nueva clave SSH para utilizarla con Gitea en tu PC local.

$ ssh-keygen -f ~/.ssh/gitea-demo -t rsa -b 4096 -C "HowtoForge Gitea Demo" -q -N "yourpassphrase"

Introduce una frase de contraseña fuerte en lugar del marcador de posición del comando anterior. Esto creará una clave SSH en la ubicación ~/.ssh/gitea-demo.

A continuación, abre la configuración de tu perfil de Gitea como se muestra haciendo clic en el menú desplegable de la imagen de tu perfil y seleccionando la opción Configuración.

A continuación, cambia a la pestaña Claves SSH/GPG de la página.

Añade un nombre para tu clave SSH. Vuelve al terminal de tu PC local y ejecuta el siguiente comando para obtener la clave pública de Gitea.

$ cat ~/.ssh/gitea-demo.pub

Copia el resultado y pégalo en la casilla Contenido de la página Claves SSH de Gitea.

Pulsa el botón Añadir Clave para terminar de añadir la clave.

Vuelve a tu PC local y configura el agente SSH para que permanezca activo durante 1 hora.

$ eval $(ssh-agent -t 3600)b

Añade la clave SSH recién creada al agente SSH.

$ ssh-add ~/.ssh/gitea-demo
Enter passphrase for /home/navjot/.ssh/gitea-demo:
Identity added: /home/navjot/.ssh/gitea-demo (HowtoForge Gitea Demo)

Se te pedirá tu frase de contraseña.

Paso 10 – Clonar el repositorio mediante SSH

Clonemos el repositorio recién creado utilizando SSH. Visita de nuevo la página del repositorio y copia la URL SSH después de seleccionar la opción SSH.

Debería tener el siguiente aspecto.

ssh://[email protected]:2221/navjot/howtoforge.git

Ejecuta el siguiente comando en tu PC local para clonar el repositorio utilizando SSH.

$ git clone ssh://[email protected]:2221/navjot/howtoforge.git
Cloning into 'howtoforge'...
The authenticity of host '[gitea.example.com]:2221 ([209.23.11.75]:2221)' can't be established.
ECDSA key fingerprint is SHA256:sN0N4OkpChwuR00xpGZU1mGJrp7ktwHRC7uxGP7Nh08.
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added '[gitea.example.com]:2221,[209.23.11.75]:2221' (ECDSA) to the list of known hosts.
remote: Enumerating objects: 4, done.
remote: Counting objects: 100% (4/4), done.
remote: Compressing objects: 100% (3/3), done.
remote: Total 4 (delta 0), reused 0 (delta 0), pack-reused 0
Receiving objects: 100% (4/4), done.

Se te pedirá que añadas las credenciales del host. Introduce yes para proceder a clonar el repositorio.

Verás el repositorio clonado en tu sistema.

$ ls
howtoforge

Cambia al directorio.

$ cd howtoforge

Comprueba el estado Git del repositorio recién clonado. Para ello, debes tener instalado Git en tu PC local.

$ git status
On branch master
Your branch is up to date with 'origin/master'.

nothing to commit, working tree clean

Esto concluye que SSH funciona perfectamente.

Paso 11 – Probar la primera confirmación

Ahora que hemos creado nuestro primer repositorio, es hora de hacer algunos cambios y confirmarlos.

Actualicemos el archivo README.md. En tu PC local, abre el archivo readme para editarlo.

$ nano README.md

Edita el archivo y, cuando hayas terminado, guárdalo pulsando Ctrl + X e introduciendo Y cuando se te pida.

Comprueba de nuevo el estado Git.

$ git status
On branch master
Your branch is up to date with 'origin/master'.

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
        modified:   README.md

no changes added to commit (use "git add" and/or "git commit -a")

Esto muestra que el archivo Léame ha sido editado pero no confirmado. Añade el archivo para prepararlo para la confirmación.

$ git add README.md

Confirma el archivo.

$ git commit -m "Update the Readme file for Gitea tutorial."
[master 5e9b039] Update the Readme file for Gitea tutorial.
 1 file changed, 3 insertions(+), 1 deletion(-)

Envía el archivo a tu servidor Gitea.

$ git push origin master
Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 4 threads
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 392 bytes | 392.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0)
remote: . Processing 1 references
remote: Processed 1 references in total
To ssh://gitea.example.com:2221/navjot/howtoforge.git
   a61dfce..5e9b039  master -> master

Para confirmar, vuelve a la página del repositorio Gitea.

Verás que el archivo Léame se ha actualizado, y también se muestra el último mensaje de confirmación. Para ver los cambios, haz clic en el mensaje de confirmación, y podrás ver la siguiente página con las diferencias.

Esto concluye la primera confirmación de nuestro repositorio. Puedes empezar a trabajar en tu instalación de Gitea para tus proyectos.

Paso 12 – Actualizar Gitea

Actualizar Gitea es un proceso sencillo.

Cierra y elimina los contenedores existentes. Como los datos se guardan fuera de los contenedores en el host, se conservarán.

$ cd ~/gitea-docker
$ docker-compose down --remove-orphans

Abre el archivo docker-compose.yml y cambia la versión del contenedor Gitea. A continuación, extrae la nueva imagen de Gitea.

$ docker pull

Inicia los nuevos contenedores.

$ docker-compose up -d

Comprueba el estado.

$ docker ps

Conclusión

Con esto concluye nuestro tutorial en el que hemos instalado el Servicio de Alojamiento de Código Gitea utilizando Docker en un servidor Linux Rocky. También instalamos el servidor Nginx para que actuara como proxy y expusimos Gitea a través de una URL pública utilizando SSL. Si tienes alguna pregunta, publícala en los comentarios a continuación.