Cómo instalar la plataforma Gitea DevOps usando Docker en Debian 12

Gitea es una solución de alojamiento de código abierto basada en la plataforma Git. Está escrito en lenguaje Go y puede instalarse en múltiples sistemas operativos, como Linux, macOS, Windows y arquitecturas como amd64, i386, ARM y otras. Incluye un editor de archivos de repositorio, seguimiento de incidencias, pull requests, gestión de usuarios, notificaciones, wiki incorporado, soporte LFS, ganchos Git y mucho más.

Es una aplicación ligera. Por tanto, puede instalarse en sistemas poco potentes. Si estás buscando una plataforma Git autoalojada con poca memoria, deberías echar un vistazo a Gitea.

Este artículo cubrirá la instalación y configuración de Gitea en un servidor Debian 12 y la creación de tu primer repositorio Git. Gitea puede instalarse desde el código fuente, desde un binario, desde un paquete Docker o desde un paquete. Para nuestro tutorial, lo instalaremos utilizando Docker.

Requisitos previos

• Un servidor con Debian 12.
• Un usuario no root con privilegios sudo.
• Un nombre de dominio completo (FQDN) como gitea.example.com que apunte a tu servidor.
• Asegúrate de que tu servidor tiene habilitado el almacenamiento swap si estás en un servidor con 1 GB de RAM.
• Asegúrate de que todo está actualizado.

  $ sudo apt update && sudo apt upgrade
  

• Se necesitan algunos paquetes esenciales antes de seguir adelante. Algunos de ellos ya estarán instalados en tu servidor.

  $ sudo apt install curl wget nano software-properties-common dirmngr apt-transport-https ca-certificates lsb-release debian-archive-keyring gnupg2 ufw unzip -y
  

Paso 1 – Configurar el cortafuegos

El primer paso es configurar el cortafuegos. Debian viene con ufw (Uncomplicated Firewall) por defecto.

Comprueba si el cortafuegos se está ejecutando.

$ sudo ufw status

Obtendrás la siguiente salida.

Status: inactive

Permite el puerto SSH para que el cortafuegos no rompa la conexión actual al activarlo.

$ sudo ufw allow OpenSSH

Permite también los puertos HTTP y HTTPS.

$ sudo ufw allow http
$ sudo ufw allow https

Habilita el cortafuegos

$ sudo ufw enable
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup

Comprueba de nuevo el estado del cortafuegos.

$ sudo ufw status

Deberías ver un resultado similar.

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere
443                        ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80/tcp (v6)                ALLOW       Anywhere (v6)
443 (v6)                   ALLOW       Anywhere (v6)

Paso 2 – Instala Docker y Docker Compose

Debian 12 incluye una versión antigua de Docker. Para instalar la última versión, importa primero la clave GPG de Docker.

$ curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker.gpg

Crea un archivo de repositorio de Docker.

$ echo \
  "deb [arch="$(dpkg --print-architecture)" signed-by=/usr/share/keyrings/docker.gpg] https://download.docker.com/linux/debian \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Actualiza la lista de repositorios del sistema.

$ sudo apt update

Instala la última versión de Docker.

$ sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Comprueba que se está ejecutando.

$ sudo systemctl status docker
? docker.service - Docker Application Container Engine
     Loaded: loaded (/lib/systemd/system/docker.service; enabled; preset: enabled)
     Active: active (running) since Sat 2023-11-18 07:13:39 UTC; 10s ago
TriggeredBy: ? docker.socket
       Docs: https://docs.docker.com
   Main PID: 1891 (dockerd)
      Tasks: 8
     Memory: 27.2M
        CPU: 338ms
     CGroup: /system.slice/docker.service
             ??1891 /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 o utilizar el siguiente comando.

$ su - ${USER}

Confirma que tu usuario se ha añadido al grupo Docker.

$ groups
navjot sudo users docker

Paso 3 – Crear un usuario Git

Para que los usuarios puedan acceder al host a través de SSH, tendrás que crear un usuario git independiente en el host. Ejecuta el siguiente comando para crear el usuario git.

$ sudo adduser --system --shell /bin/bash --gecos 'Git Version Control' --group --disabled-password --home /home/git git

Repasemos todas las opciones y banderas del comando anterior para una mejor comprensión.

• --system – crea un usuario de sistema en lugar de un usuario normal. Los usuarios del sistema sirven para ejecutar servicios del sistema y no pueden utilizarse para inicios de sesión interactivos.
• --shell /bin/bash – establece el shell de inicio de sesión para el usuario del sistema en el shell Bash.
• --gecos 'Git Version Control' – establece un campo descriptivo para el usuario. Es opcional y puede omitirse, pero es útil si tu sistema tiene muchos usuarios.
• --group – crea un grupo con el mismo nombre que el usuario.
• --disabled-password – desactiva el inicio de sesión basado en contraseña para el usuario, lo que ayuda a proteger la cuenta.
• --home /home/git – establece el directorio de inicio para el usuario en /home/git, que almacena los archivos y la configuración del usuario.
• git – especifica el nombre de usuario. Aquí estamos utilizando git como nombre de usuario para la cuenta.

Obtendrás la siguiente salida cuando ejecutes el comando.

Adding system user `git' (UID 105) ...
Adding new group `git' (GID 111) ...
Adding new user `git' (UID 105) with group `git' ...
Creating home directory `/home/git' ...

Observa los valores de las variables UID y GID que necesitaremos en el siguiente paso. En nuestro caso, UID es 105 y GID es 111.

Paso 4 – Configurar e instalar Gitea

Configurar la zona horaria del sistema

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

$ timedatectl
               Local time: Sat 2023-11-18 07:15:53 UTC
           Universal time: Sat 2023-11-18 07:15:53 UTC
                 RTC time: Sat 2023-11-18 07:15:53
                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 con 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: Sat 2023-11-18 12:46:29 IST
           Universal time: Sat 2023-11-18 07:16:29 UTC
                 RTC time: Sat 2023-11-18 07:16:29
                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

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.

services:
  server:
    image: gitea/gitea:1.21.0
    container_name: gitea
    environment:
      - USER_UID=105
      - USER_GID=111
      - 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
      - /home/git/.ssh/:/data/git/.ssh
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "3000:3000"
      - "2221:22"
    depends_on:
      - db

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

networks:
  gitea:
    external: false

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

Estamos utilizando los valores UID (Identificador de Usuario) y GID (Identificador de Grupo) para el usuario que creamos en el paso anterior.

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 de composición es el que utilizará el contenedor Gitea para crear el directorio gitea. Por otro lado, 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
3b5ce50a04fe   gitea/gitea:1.21.0   "/usr/bin/entrypoint…"   43 seconds ago   Up 42 seconds   0.0.0.0:3000->3000/tcp, :::3000->3000/tcp, 0.0.0.0:2221->22/tcp, :::2221->22/tcp   gitea
0908cb9ec3b7   postgres:15          "docker-entrypoint.s…"   43 seconds ago   Up 42 seconds   5432/tcp                                                                           gitea-docker-db-1

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

$ docker compose ps
NAME                IMAGE                COMMAND                                        SERVICE   CREATED              STATUS              PORTS
gitea               gitea/gitea:1.21.0   "/usr/bin/entrypoint /bin/s6-svscan /etc/s6"   server    About a minute ago   Up About a minute   0.0.0.0:3000->3000/tcp, :::3000->3000/tcp, 0.0.0.0:2221->22/tcp, :::2221->22/tcp
gitea-docker-db-1   postgres:15          "docker-entrypoint.sh postgres"                db        About a minute ago   Up About a minute   5432/tcp

Paso 5 – Instala Nginx

Debian 12 incluye una versión antigua de Nginx. Para instalar la última versión, tienes que descargar el repositorio oficial de Nginx.

Importa la clave de firma de Nginx.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
    | sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Añade el repositorio de la versión estable de Nginx.

$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg] \
http://nginx.org/packages/debian `lsb_release -cs` nginx" \
    | sudo tee /etc/apt/sources.list.d/nginx.list

Actualiza los repositorios del sistema.

$ sudo apt update

Instala Nginx.

$ sudo apt install nginx

Verifica la instalación. En los sistemas Debian, el siguiente comando sólo funcionará con sudo.

$ sudo nginx -v
nginx version: nginx/1.24.0

Inicia el servidor Nginx.

$ sudo systemctl start nginx

Comprueba el estado del servicio.

$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
     Loaded: loaded (/lib/systemd/system/nginx.service; enabled; preset: enabled)
     Active: active (running) since Sat 2023-11-18 15:47:20 IST; 1s ago
       Docs: https://nginx.org/en/docs/
    Process: 4225 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
   Main PID: 4226 (nginx)
      Tasks: 2 (limit: 2315)
     Memory: 1.8M
        CPU: 7ms
     CGroup: /system.slice/nginx.service
             ??4226 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
             ??4227 "nginx: worker process"

Abre la dirección IP de tu servidor en tu navegador web. Deberías ver la siguiente página, lo que significa que tu servidor está en funcionamiento.

Paso 6 – Instalar SSL

Necesitamos instalar Certbot para generar el certificado SSL. Puedes instalar Certbot utilizando el repositorio de Debian u obtener la última versión utilizando la herramienta Snapd. Nosotros utilizaremos la versión Snapd.

Debian 12 no viene con Snapd instalado. Instala el paquete Snapd.

$ sudo apt install snapd

Ejecuta los siguientes comandos para asegurarte de que tu versión de Snapd está actualizada.

$ sudo snap install core && sudo snap refresh core

Instala Certbot.

$ sudo snap install --classic certbot

Utiliza el siguiente comando para asegurarte de que se puede ejecutar el comando Certbot creando un enlace simbólico al directorio /usr/bin.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Comprueba si Certbot funciona correctamente.

$ certbot --version
certbot 2.7.4

Genera el certificado SSL.

$ sudo certbot certonly --nginx --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 -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Comprueba el servicio programador de renovación de Certbot.

$ sudo systemctl list-timers

Encontrarás snap.certbot.renew.service como uno de los servicios programados para ejecutarse.

NEXT                        LEFT           LAST                        PASSED      UNIT                      ACTIVATES     
---------------------------------------------------------------------------------------------------------------------------               
Sat 2023-11-18 18:41:45 IST 2h 49min left Sat 2023-11-18 12:22:34 IST 3h 29min ago apt-daily.timer           apt-daily.service
Sat 2023-11-18 20:40:00 IST 4h 47min left -                           -            snap.certbot.renew.timer  snap.certbot.renew.service
Sun 2023-11-19 00:00:00 IST 8h left       -                           -            dpkg-db-backup.timer      dpkg-db-backup.service

Realiza una ejecución en seco del proceso para comprobar si la renovación SSL funciona correctamente.

$ sudo certbot renew --dry-run

Si no ves ningún error, ya está todo listo. Tu certificado se renovará automáticamente.

Paso 7 – Configurar Nginx

Ejecuta el siguiente comando para añadir un archivo de configuración para tu sitio.

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

Pega el siguiente código en el editor.

# Connection header for WebSocket reverse proxy
map $http_upgrade $connection_upgrade {
    default upgrade;
    ""      close;
}

map $remote_addr $proxy_forwarded_elem {

    # IPv4 addresses can be sent as-is
    ~^[0-9.]+$ "for=$remote_addr";

    # IPv6 addresses need to be bracketed and quoted
    ~^[0-9A-Fa-f:.]+$ "for=\"[$remote_addr]\"";

    # Unix domain socket names cannot be represented in RFC 7239 syntax
    default "for=unknown";
}

map $http_forwarded $proxy_add_forwarded {

   # If the incoming Forwarded header is syntactically valid, append to it
    "~^(,[ \\t]*)*([!#$%&'*+.^_`|~0-9A-Za-z-]+=([!#$%&'*+.^_`|~0-9A-Za-z-]+|\"([\\t \\x21\\x23-\\x5B\\x5D-\\x7E\\x80-\\xFF]|\\\\[\\t \\x21-\\x7E\\x80-\\xFF])*\"))?(;([!#$%&'*+.^_`|~0-9A-Za-z-]+=([!#$%&'*+.^_`|~0-9A-Za-z-]+|\"([\\t \\x21\\x23-\\x5B\\x5D-\\x7E\\x80-\\xFF]|\\\\[\\t \\x21-\\x7E\\x80-\\xFF])*\"))?)*([ \\t]*,([ \\t]*([!#$%&'*+.^_`|~0-9A-Za-z-]+=([!#$%&'*+.^_`|~0-9A-Za-z-]+|\"([\\t \\x21\\x23-\\x5B\\x5D-\\x7E\\x80-\\xFF]|\\\\[\\t \\x21-\\x7E\\x80-\\xFF])*\"))?(;([!#$%&'*+.^_`|~0-9A-Za-z-]+=([!#$%&'*+.^_`|~0-9A-Za-z-]+|\"([\\t \\x21\\x23-\\x5B\\x5D-\\x7E\\x80-\\xFF]|\\\\[\\t \\x21-\\x7E\\x80-\\xFF])*\"))?)*)?)*$" "$http_forwarded, $proxy_forwarded_elem";

    # Otherwise, replace it
    default "$proxy_forwarded_elem";
}

# 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;
    resolver 1.1.1.1 1.0.0.1 [2606:4700:4700::1111] [2606:4700:4700::1001] 8.8.8.8 8.8.4.4 [2001:4860:4860::8888] [2001:4860:4860::8844] valid=60s;
    resolver_timeout 2s;

    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.access.log main;
    error_log  /var/log/nginx/gitea.error.log;

    tcp_nopush on;

    # security headers
    add_header X-XSS-Protection "1; mode=block" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header Referrer-Policy "no-referrer-when-downgrade" always;
    add_header Content-Security-Policy "default-src 'self' http: https: ws: wss: data: blob: 'unsafe-inline'; frame-ancestors 'self';" always;
    add_header Permissions-Policy "interest-cohort=()" always;

    # . files
    location ~ /\.(?!well-known) {
        deny all;
    }

    location / {
        client_max_body_size 100M;
        proxy_pass  http://localhost:3000;
        proxy_http_version 1.1;
        proxy_cache_bypass $http_upgrade;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection $connection_upgrade;
        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_set_header X-Forwarded-Port $server_port;
        proxy_set_header Forwarded $proxy_add_forwarded;
        proxy_connect_timeout 60s;
        proxy_send_timeout 60s;
        proxy_read_timeout 60s;
    }
}

Cuando hayas terminado, pulsa Ctrl + X para cerrar el editor y pulsa Y cuando se te pida guardar el archivo.

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. Prueba la configuración de Nginx.

$ sudo nginx -t

Deberías ver la siguiente salida indicando que tu configuración es correcta.

nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Recarga el servicio Nginx.

$ sudo systemctl reload nginx

Paso 8 – 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 y Requerir inicio de sesión para ver las páginas para mantener la privacidad de nuestro sitio Git. Si no quieres que la gente registre una cuenta, activa la opción Desactivar autorregistro.

Por último, pero no 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 segura 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)

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 ([128.199.48.13]:2221)' can't be established.
ED25519 key fingerprint is SHA256:H7t5hNmEpZkYC9u3sXbA1mnGXCnoqaUZGL+gpAG9uNs.
This key is not known by any other names
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added '[gitea.example.com]:2221' (ED25519) to the list of known hosts.
remote: Enumerating objects: 4, done.
remote: Counting objects: 100% (4/4), done.
remote: Compressing objects: 100% (4/4), 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 main
Your branch is up to date with 'origin/main'.

nothing to commit, working tree clean

Esto concluye que SSH funciona perfectamente.

Paso 11 – Probar el primer commit

Ahora que hemos configurado 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 main
Your branch is up to date with 'origin/main'.

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."
[main bb2956f] 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 main
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), 378 bytes | 378.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
remote: . Processing 1 references
remote: Processed 1 references in total
To ssh://gitea.example.com:2221/navjot/howtoforge.git
   bd1248f..bb2956f  main -> main

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

Puedes ver 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 – Copia de seguridad y restauración de Gitea

Gitea incluye una herramienta de línea de comandos que puede realizar copias de seguridad utilizando un único comando. Para ejecutar la herramienta de línea de comandos dentro del contenedor docker para realizar la copia de seguridad, ejecuta el siguiente comando.

$ docker exec -u git -it -w /app/gitea gitea bash -c '/usr/local/bin/gitea dump -c /data/gitea/conf/app.ini'

Estamos ejecutando el comando como el mismo usuario que creamos en el paso 3 y configuramos durante la instalación utilizando la bandera -u git en el comando anterior. La bandera -w /app/gitea define la carpeta dentro del contenedor docker donde se almacenará el archivo de copia de seguridad. La carpeta de copia de seguridad debe elegirse de forma que el usuario git tenga permiso para escribir en ella. Dentro del contenedor docker, sólo hay dos carpetas de este tipo. Una es la carpeta /data y la otra es la carpeta /app/gitea. No podemos utilizar la carpeta /data porque la herramienta de línea de comandos realiza una copia de seguridad de toda la carpeta de datos, que entra en un bucle indefinido si la utilizamos como destino, lo que puede llenar el espacio de tu servidor. Por lo tanto, sólo podemos almacenar la copia de seguridad en la carpeta /app/gitea.

Lo siguiente en el comando es el nombre del contenedor, gitea. Después, especificamos el tipo de shell Linux que se utiliza para ejecutar el comando dentro del contenedor. La bandera -c especifica el comando que hay que ejecutar dentro del contenedor. Y el comando a ejecutar es /usr/local/bin/gitea dump -c /data/gitea/conf/app.ini, que ejecuta la herramienta de línea de comandos y especifica la ubicación del archivo de configuración que la acompaña.

Una vez ejecutado el comando, verás la siguiente salida.

2023/11/20 06:21:41 ...les/setting/cache.go:75:loadCacheFrom() [I] Cache Service Enabled
2023/11/20 06:21:41 ...les/setting/cache.go:90:loadCacheFrom() [I] Last Commit Cache Service Enabled
2023/11/20 06:21:41 ...s/setting/session.go:74:loadSessionFrom() [I] Session Service Enabled
2023/11/20 06:21:41 ...es/setting/mailer.go:237:loadMailerFrom() [I] Mail Service Enabled
2023/11/20 06:21:41 ...es/setting/mailer.go:259:loadNotifyMailFrom() [I] Notify Mail Service Enabled
2023/11/20 06:21:41 ...s/storage/storage.go:176:initAttachments() [I] Initialising Attachment storage with type: local
2023/11/20 06:21:41 ...les/storage/local.go:33:NewLocalStorage() [I] Creating new Local Storage at /data/gitea/attachments
2023/11/20 06:21:41 ...s/storage/storage.go:166:initAvatars() [I] Initialising Avatar storage with type: local
2023/11/20 06:21:41 ...les/storage/local.go:33:NewLocalStorage() [I] Creating new Local Storage at /data/gitea/avatars
2023/11/20 06:21:41 ...s/storage/storage.go:192:initRepoAvatars() [I] Initialising Repository Avatar storage with type: local
2023/11/20 06:21:41 ...les/storage/local.go:33:NewLocalStorage() [I] Creating new Local Storage at /data/gitea/repo-avatars
2023/11/20 06:21:41 ...s/storage/storage.go:186:initLFS() [I] Initialising LFS storage with type: local
2023/11/20 06:21:41 ...les/storage/local.go:33:NewLocalStorage() [I] Creating new Local Storage at /data/git/lfs
2023/11/20 06:21:41 ...s/storage/storage.go:198:initRepoArchives() [I] Initialising Repository Archive storage with type: local
2023/11/20 06:21:41 ...les/storage/local.go:33:NewLocalStorage() [I] Creating new Local Storage at /data/gitea/repo-archive
2023/11/20 06:21:41 ...s/storage/storage.go:208:initPackages() [I] Initialising Packages storage with type: local
2023/11/20 06:21:41 ...les/storage/local.go:33:NewLocalStorage() [I] Creating new Local Storage at /data/gitea/packages
2023/11/20 06:21:41 ...s/storage/storage.go:219:initActions() [I] Initialising Actions storage with type: local
2023/11/20 06:21:41 ...les/storage/local.go:33:NewLocalStorage() [I] Creating new Local Storage at /data/gitea/actions_log
2023/11/20 06:21:41 ...s/storage/storage.go:223:initActions() [I] Initialising ActionsArtifacts storage with type: local
2023/11/20 06:21:41 ...les/storage/local.go:33:NewLocalStorage() [I] Creating new Local Storage at /data/gitea/actions_artifacts
2023/11/20 06:21:41 cmd/dump.go:265:runDump() [I] Dumping local repositories... /data/git/repositories
2023/11/20 06:21:41 cmd/dump.go:306:runDump() [I] Dumping database...
2023/11/20 06:21:41 cmd/dump.go:318:runDump() [I] Adding custom configuration file from /data/gitea/conf/app.ini
2023/11/20 06:21:41 cmd/dump.go:334:runDump() [I] Custom dir /data/gitea is inside data dir /data/gitea, skipped
2023/11/20 06:21:41 cmd/dump.go:346:runDump() [I] Packing data directory.../data/gitea
2023/11/20 06:21:41 cmd/dump.go:430:runDump() [I] Finish dumping in file gitea-dump-1700441501.zip

Ahora, vamos a realizar el proceso de restauración. Deberías tener una nueva instalación Docker de Gitea en ejecución. Pero no realices el proceso de instalación.

Accede al shell de Docker.

$ docker exec --user git -it gitea bash

Cambia al directorio app/gitea.

$ cd app/gitea

Descomprime el archivo de copia de seguridad.

$ unzip gitea-dump-1700441501.zip

Cambia al directorio extraído.

$ cd gitea-dump-1700441501

Restaura la carpeta /data/gitea.

$ mv data/* /data/gitea

Restaura los repositorios.

$ mv repos/* /data/git/gitea-repositories/

Corrige los permisos de los archivos.

$ chown -R git:git /data

Regenera los Git Hooks.

$ /usr/local/bin/gitea -c '/data/gitea/conf/app.ini' admin regenerate hooks

Sal del docker shell.

$ exit

Paso 13 – 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 Debian 12. También hemos instalado el servidor Nginx para que actúe como proxy y hemos expuesto Gitea a través de una URL pública utilizando SSL. Si tienes alguna pregunta, publícala en los comentarios a continuación.