Cómo instalar Gitea en Ubuntu usando Docker

Introducción

Cuando se trabaja en el desarrollo de software, es importante poder administrar el código fuente de manera eficiente y rastreable. Gestión de código fuente (SCM ) son una excelente manera de proporcionar un proceso eficiente y flexible para trabajar en proyectos de cualquier tamaño con cualquier número de desarrolladores. Han existido muchas piezas diferentes de software SCM a lo largo de los años, desde CVS a SubVersion, Perforce a Mercurial, pero el líder actual de la industria es Git, que ha experimentado un gran crecimiento con la popularidad de sitios como GitHub y GitLab.

Sin embargo, con cuentas gratuitas en estos servicios orientados a repositorios públicos de código abierto, la capacidad de trabajar en software privado o propietario genera un costo para el desarrollador. Además, el acceso de uno al repositorio está sujeto a una organización externa, y muchos preferirían controlar su propio software de principio a fin.

Con ese fin, en los últimos años se han desarrollado varias soluciones autohospedadas como Gogs, Gitea y GitLab. Este tutorial se enfoca en configurar una de las soluciones más populares, Gitea, para permitirle alojar repositorios privados y administrar sus propios proyectos a lo largo de todo su ciclo de vida. Gitea es pequeño, autónomo y liviano, lo que lo convierte en un proceso rápido de implementación sin tener que gastar mucho dinero en requisitos de hardware. Utilizará una instalación Docker de Gitea, lo que garantiza que el software se mantendrá actualizado.

Requisitos

Antes de comenzar este tutorial, debe tener lo siguiente:

• Un servidor Ubuntu 20.04 con un usuario no root configurado con sudo privilegios como se describe en la configuración inicial del servidor para Ubuntu 20.04.
• Docker instalado en su servidor. Siga los Pasos 1 y 2 de Cómo instalar Docker en Ubuntu 20.04 para instalar Docker.
• Docker Compose instalado en su servidor. Siga el Paso 1 de nuestra guía sobre cómo instalar y usar Docker Compose en Ubuntu 20.04 para configurarlo.
• Un nombre de dominio dirigido a su servidor. Si está utilizando un Droplet de DigitalOcean, puede lograrlo siguiendo nuestra documentación de Dominios y DNS. Este tutorial usará your_domain en ejemplos a lo largo.

Paso 1:crear el usuario de Git

Gitea, como muchos repositorios de código fuente, usa SSH para acceder a repositorios remotos. Esto permite a los usuarios controlar el acceso a su código mediante la gestión de sus claves SSH dentro de Gitea. Sin embargo, para que los usuarios puedan acceder al host a través de SSH, deberá crear un git usuario en la máquina host. Este paso se completa primero para que pueda acceder al ID de usuario y grupo del usuario.

Primero, cree el usuario en el host que aceptará estas conexiones:

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

En este comando, crea un usuario del sistema que usa bash como shell, pero no tiene una contraseña de inicio de sesión. Esto le permite usar sudo para ejecutar comandos como ese usuario, pero evita iniciar sesión como tal. También establece el directorio de inicio del usuario en /home/git .

Este comando generará información sobre el usuario que acaba de crear:

OutputAdding system user `git' (UID 112) ...
Adding new group `git' (GID 119) ...
Adding new user `git' (UID 112) with group `git' ...
Creating home directory `/home/git' …

Tome nota de los valores de UID y GID proporcionados aquí (en este caso, un UID de 112 y un GID de 119 ), ya que se utilizarán en un paso futuro.

Paso 2:Instalación de la imagen de Gitea Docker

Gitea tiene una imagen disponible en el repositorio global de Docker, lo que significa que, con Docker Compose, puede instalar y ejecutar esa imagen como un servicio con poco trabajo adicional. La imagen en sí ejecuta los servicios web y SSH de Gitea, lo que permite el acceso a Git tanto desde el navegador como desde la línea de comandos.

Para activar el contenedor de Gitea, utilizará Docker Compose, una herramienta declarativa para configurar un entorno.

Para empezar, cree un directorio para alojar su servicio e ingréselo:

mkdir ~/gitea
cd ~/gitea

Una vez allí, crea un archivo llamado docker-compose.yml utilizando su editor de texto preferido. El siguiente ejemplo usa nano . Este archivo contendrá las descripciones de los contenedores que se ejecutarán como parte de su instalación de Gitea:

nano docker-compose.yml

Agregue lo siguiente en este nuevo archivo:

~/gitea/docker-compose.yml

version: "3"

networks:
  gitea:
    external: false

services:
  server:
    image: gitea/gitea:1.16.5
    container_name: gitea
    environment:
      - USER_UID=UID_from_step_1
      - USER_GID=GID_from_step_1
    restart: always
    networks:
      - gitea
    volumes:
      - ./gitea:/data
      - /home/git/.ssh/:/data/git/.ssh
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "127.0.0.1:3000:3000"
      - "127.0.0.1:2222:22"

Veamos qué hace este archivo:

• version: "3" :esto le permite a Docker Compose qué versión del archivo de configuración es.
• networks :esta sección declara la configuración de red de nuestra colección de contenedores. En este caso, una gitea la red se crea, pero no se expone externamente.
• services
  • image: gitea/gitea:1.16.5 :esto especifica que usaremos Gitea versión 1.16.5; sin embargo, puede cambiar el valor después de los dos puntos para especificar otras versiones, ya sea una versión específica, una versión principal como :1 , o una etiqueta como :latest o :dev .
  • environment :la sección de entorno especifica las variables de entorno que estarán disponibles para la imagen durante la instalación y ejecución. En este caso, estamos especificando un ID de usuario y de grupo para el entorno, utilizando el UID y el GID proporcionados en la salida de adduser comando en el Paso 1.
  • restart: always :esta línea le indica a Docker que siempre reinicie el contenedor si se cae, ya sea porque el propio contenedor se cae o porque la máquina host lo hace; esencialmente, Gitea se iniciará en el arranque.
  • networks :esto especifica que el servicio de Gitea tendrá acceso y será accesible en la red mencionada anteriormente.
  • ./gitea:/data y /home/git/.ssh/:/data/git/.ssh :estas son las ubicaciones donde Gitea almacenará sus repositorios y datos relacionados. Actualmente, esto está asignado a la carpeta llamada gitea en el directorio actual. Docker creará esta carpeta cuando se inicie el contenedor si no existe. El .ssh La carpeta se describirá más adelante en el Paso 6.
  • /etc/timezone y /etc/localtime :estos dos archivos contienen información sobre la zona horaria y la hora en la máquina host. Mapeándolos directamente en el contenedor como archivos de solo lectura (especificados con el :ro final parte de las definiciones), el contenedor tendrá la misma información que el host.
  • ports :Gitea escucha conexiones en dos puertos. Escucha conexiones HTTP en el puerto 3000 , donde sirve la interfaz web para el repositorio de código fuente y escucha las conexiones SSH en el puerto 22 . En este caso, mantiene el puerto 3000 para conexiones HTTP asignándolo al mismo número, y está asignando el puerto en el contenedor de Gitea desde el 22 habitual a 2222 para evitar el conflicto de puertos. En el Paso 6, configurará un shim SSH para dirigir el tráfico a Gitea cuando se le solicite.

Nota: Este es un ejemplo mínimo de un archivo Docker Compose para Gitea. Hay varias otras opciones que se pueden incluir, como usar MySQL o PostGreSQL como base de datos de respaldo o un volumen con nombre para el almacenamiento. Esta configuración mínima usa SQLite como base de datos de respaldo y un volumen que usa el directorio llamado gitea para almacenamiento. Puede leer más sobre estas opciones en la documentación de Gitea.

Guarde y cierre el archivo. Si usaste nano para editar el archivo, puede hacerlo presionando CTRL + X , Y y luego ENTER .

Con este archivo en su lugar, puede abrir los contenedores usando Docker Compose:

docker-compose up

Este comando desplegará las imágenes, iniciará el contenedor de Gitea y devolverá un resultado como este:

Output[+] Running 9/9
 ⠿ server Pulled                                                                                                  8.2s
   ⠿ e1096b72685a Pull complete                                                                                   1.4s
   ⠿ ac9df86bb932 Pull complete                                                                                   3.3s
   ⠿ 6d34ed99b58a Pull complete                                                                                   3.4s
   ⠿ a8913d040fab Pull complete                                                                                   3.6s
   ⠿ a5d3a72a2366 Pull complete                                                                                   5.3s
   ⠿ 1f0dcaae29cc Pull complete                                                                                   5.6s
   ⠿ f284bcea5adb Pull complete                                                                                   7.3s
   ⠿ 0f09c34c97e3 Pull complete                                                                                   7.5s
[+] Running 2/2
 ⠿ Network gitea_gitea  Created                                                                                   0.2s
 ⠿ Container gitea      Created                                                                                   0.2s
Attaching to gitea
gitea  | Generating /data/ssh/ssh_host_ed25519_key...
gitea  | Generating /data/ssh/ssh_host_rsa_key...
gitea  | Generating /data/ssh/ssh_host_dsa_key...
gitea  | Generating /data/ssh/ssh_host_ecdsa_key...
gitea  | Server listening on :: port 22.
gitea  | Server listening on 0.0.0.0 port 22.
gitea  | 2022/03/31 17:26:21 cmd/web.go:102:runWeb() [I] Starting Gitea on PID: 14
gitea  | 2022/03/31 17:26:21 ...s/install/setting.go:21:PreloadSettings() [I] AppPath: /usr/local/bin/gitea
gitea  | 2022/03/31 17:26:21 ...s/install/setting.go:22:PreloadSettings() [I] AppWorkPath: /app/gitea
gitea  | 2022/03/31 17:26:21 ...s/install/setting.go:23:PreloadSettings() [I] Custom path: /data/gitea
gitea  | 2022/03/31 17:26:21 ...s/install/setting.go:24:PreloadSettings() [I] Log path: /data/gitea/log
gitea  | 2022/03/31 17:26:21 ...s/install/setting.go:25:PreloadSettings() [I] Configuration file: /data/gitea/conf/app.ini
gitea  | 2022/03/31 17:26:21 ...s/install/setting.go:26:PreloadSettings() [I] Prepare to run install page
gitea  | 2022/03/31 17:26:21 ...s/install/setting.go:29:PreloadSettings() [I] SQLite3 is supported
gitea  | 2022/03/31 17:26:21 cmd/web.go:208:listen() [I] Listen: http://0.0.0.0:3000
gitea  | 2022/03/31 17:26:21 cmd/web.go:212:listen() [I] AppURL(ROOT_URL): http://localhost:3000/

Sin embargo, esto dejará el contenedor ejecutándose en primer plano y se detendrá tan pronto como salga del proceso con Ctrl + C o por perder su conexión. Para que el contenedor se ejecute en segundo plano como un proceso separado, puede agregar -d marca al comando Redactar:

docker-compose up -d

Se le notificará cuando se inicie el contenedor y luego se le devolverá a su caparazón.

Paso 3:Instalar Nginx como proxy inverso

Ejecutar un servicio web como Gitea detrás de un proxy inverso es una práctica común, ya que el software de servidor moderno como Apache o Nginx puede manejar más fácilmente múltiples servicios en una máquina, equilibrar la carga en múltiples servidores y manejar SSL. Además, esto le permitirá configurar un nombre de dominio que apunta a su instancia de Gitea que se ejecuta en puertos HTTP(S) estándar.

Para los propósitos de este tutorial, usaremos Nginx. Primero, actualice las listas de paquetes en su máquina host:

sudo apt update

Luego, instale Nginx usando apt :

sudo apt install nginx

Ahora, mientras usa el cortafuegos ufw , deberá permitir el acceso a estos puertos:

sudo ufw allow "Nginx Full"

Una vez que esté instalado, debería poder acceder a su servidor en su navegador visitando http://your_domain . Esto lo llevará a una página muy simple que le da la bienvenida a Nginx.

En este punto, deberá crear una entrada de proxy inverso para dirigir el tráfico entrante a través de Nginx a la instancia de Gitea que se ejecuta en Docker. Cree un nuevo archivo en Nginx sites-available directorio utilizando su editor de texto preferido. El siguiente ejemplo usa nano :

sudo nano /etc/nginx/sites-available/gitea

En este archivo, configure un nuevo bloque de servidor con solicitudes a / enviado a su instancia de Gitea:

/etc/nginx/sites-disponible/gitea

server {
    # Listen for requests on your domain/IP address.
    server_name your_domain;

    root /var/www/html;

    location / {
        # Proxy all requests to Gitea running on port 3000
        proxy_pass http://localhost:3000;
        
        # Pass on information about the requests to the proxied service using headers
        proxy_set_header HOST $host;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

Una vez que haya terminado de editar el archivo, guárdelo y ciérrelo.

Nota: Para obtener más información sobre cómo comprender lo que sucede dentro de estas directivas, consulte el tutorial Comprender el proxy HTTP, el equilibrio de carga, el almacenamiento en búfer y el almacenamiento en caché de Nginx.

Nginx determina qué sitios servirá realmente en función de si esos archivos están presentes o no en su sites-enabled directorio. Esto se gestiona a través de enlaces simbólicos que apuntan a los archivos en los sites-available directorio. Deberá crear uno de esos enlaces simbólicos para que Nginx comience a servir a Gitea:

sudo ln -s /etc/nginx/sites-available/gitea /etc/nginx/sites-enabled/gitea

Antes de reiniciar Nginx para realizar sus cambios en vivo, debe hacer que Nginx verifique que esos cambios sean válidos probando su configuración.

sudo nginx -t

Si todo está bien, este comando devolverá un resultado como el siguiente:

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

Si hay algún problema, le dirá cuáles y dónde están.

Cuando esté listo para seguir adelante con este cambio, reinicie el servicio del sistema Nginx:

sudo systemctl restart nginx

Ahora, cuando visites http://your_domain en su navegador, debería encontrarse en la página de configuración inicial de Gitea lista para que la complete.

Paso 4:Instalación de Certbot y configuración de certificados TLS

Gracias a Certbot y la autoridad de certificación gratuita Let's Encrypt, agregar el cifrado TLS a su aplicación de instalación de Gitea solo requerirá dos comandos.

Primero, instale Certbot y su complemento Nginx:

sudo apt install certbot python3-certbot-nginx

A continuación, ejecute certbot en --nginx y especifique el mismo dominio que usó en Nginx server_name directiva de configuración:

sudo certbot --nginx -d your_domain_here

Se le pedirá que acepte los términos de servicio de Let's Encrypt y que ingrese una dirección de correo electrónico.

Luego, se le preguntará si desea redirigir todo el tráfico HTTP a HTTPS. Depende de usted, pero esto generalmente se recomienda y es seguro hacerlo.

Después de eso, Let's Encrypt confirmará su solicitud y Certbot descargará su certificado:

OutputCongratulations! You have successfully enabled https://your_domain

You should test your configuration at:
https://www.ssllabs.com/ssltest/analyze.html?d=your_domain
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

IMPORTANT NOTES:
 - Congratulations! Your certificate and chain have been saved at:
   /etc/letsencrypt/live/your_domain/fullchain.pem
   Your key file has been saved at:
   /etc/letsencrypt/live/your_domain/privkey.pem
   Your cert will expire on 2022-05-09. To obtain a new or tweaked
   version of this certificate in the future, simply run certbot again
   with the "certonly" option. To non-interactively renew *all* of
   your certificates, run "certbot renew"
 - Your account credentials have been saved in your Certbot
   configuration directory at /etc/letsencrypt. You should make a
   secure backup of this folder now. This configuration directory will
   also contain certificates and private keys obtained by Certbot so
   making regular backups of this folder is ideal.
 - If you like Certbot, please consider supporting our work by:

   Donating to ISRG / Let's Encrypt:   https://letsencrypt.org/donate
   Donating to EFF:                    https://eff.org/donate-le

Certbot recargará automáticamente Nginx con la nueva configuración y certificados. Vuelva a cargar su sitio en su navegador y debería cambiarlo a HTTPS automáticamente si elige la opción de redireccionamiento.

Su sitio ahora está seguro y es seguro continuar con los pasos de configuración basados ​​en la web.

Puede encontrar más información sobre cómo proteger dominios con Let's Encrypt en el tutorial Cómo proteger Nginx con Let's Encrypt en Ubuntu 20.04.

Paso 5:configurar Gitea y agregar un primer usuario

Ahora puede continuar con la configuración de Gitea y crear el primer usuario administrador. Visite su instancia de Gitea abriendo https://your_domain en un navegador. En la pantalla inicial de configuración de Gitea, habrá varias opciones para el servicio:

Algunos de estos, como el título del sitio, dependen de su caso de uso particular, aunque para los fines de este tutorial, deberá cambiar lo siguiente:

• Dominio del servidor: el dominio del servidor que configuró en el Paso 3
• URL base de Gitea: la URL completa que utilizará para acceder a Gitea en el navegador, incluido el protocolo. Por ejemplo, https://your_domain .

Cuando guarde los cambios de configuración, será dirigido a la página de inicio de sesión de Gitea.

Nota: Una vez guardada la configuración, el servicio de Gitea se reiniciará. Como esto puede demorar unos segundos, es posible que encuentre un error de Nginx que indique 502 Bad Gateway. . Si encuentra este error, espere unos segundos y reinicie la página.

Como aún no tiene un usuario, primero deberá crear uno. Haga clic en ¿Necesita una cuenta? Regístrese ahora enlace debajo del formulario de inicio de sesión para registrar un nuevo usuario. Como primer usuario en el sistema, este usuario se creará como administrador. Si configura la configuración de correo electrónico en la pantalla de configuración, es posible que primero deba verificar su cuenta.

Una vez que haya iniciado sesión como ese usuario, haga clic en su icono de usuario en la esquina superior derecha de la página y luego haga clic en Administración del sitio desde el menú desplegable lo llevará a una página donde podrá ejecutar trabajos de mantenimiento, administrar cuentas de usuario y organizaciones, y configurar aún más Gitea.

Creando un Repositorio de Prueba

Para probar Gitea, tanto en la interfaz web como usando Git mismo, cree un repositorio de prueba. Siempre puedes borrar este repositorio más tarde.

Haga clic en + inicie sesión en la esquina superior derecha de la página y luego haga clic en + Nuevo repositorio del menú desplegable. Aquí, se le presentará una pantalla que le permitirá nombrar y personalizar su repositorio con información como su descripción, configuraciones como si es privado o no, y cualquier contenido predeterminado como README o .gitignore archivo.

Una vez que pulses Crear repositorio , tendrás un nuevo repositorio con el que jugar.

Paso 6:configurar un SSH Shim

El paso final del proceso es preparar la máquina host con un shim SSH. Debido a que Gitea se ejecuta en un contenedor Docker, no puede aceptar conexiones SSH en el puerto predeterminado de 22 , ya que esto chocará con el host. En el docker-compose.yml archivo que creó anteriormente, Docker recibió instrucciones de asignar un puerto en el host al puerto 22 en el contenedor para que acepte conexiones SSH al puerto 2222 . Además, el SSH authorized_keys el archivo no será accesible para alguien que ingrese por SSH al host de forma predeterminada.

Para tener esto en cuenta, deberá crear un shim SSH que pasará las conexiones SSH a git usuario en el host en el contenedor. En el archivo de redacción, también especificó que el USUARIO en el contenedor tendrá un ID de usuario y grupo de 1000, y en la pantalla de configuración de Gitea, le indicó al servicio que usara el usuario llamado git .

Creando el usuario Git y su clave SSH

A continuación, deberá crear una clave SSH para el usuario. Esto solo se usará en un paso a continuación y no se compartirá con nadie fuera del host.

sudo -u git ssh-keygen -t rsa -b 4096 -C "Gitea Host Key"

Este comando usa sudo para crear una clave SSH como el usuario que creó anteriormente. En este caso, la clave será una clave RSA de 4096 bits. Se le harán una serie de preguntas, como qué contraseña desea para la clave y qué nombre debe tener el archivo de clave. Presiona ENTER para cada uno de ellos, dejándolos en blanco para aceptar el predeterminado.

Advertencia :Si establece una contraseña en la llave, no podrá usar el shim.

Deberá asegurarse de que el usuario dentro del contenedor de Gitea acepte esta clave. Puede hacer esto agregándolo a .ssh/authorized_keys archivo:

sudo -u git cat /home/git/.ssh/id_rsa.pub | sudo -u git tee -a /home/git/.ssh/authorized_keys
sudo -u git chmod 600 /home/git/.ssh/authorized_keys

Todos estos comandos funcionan con el shim debido al hecho de que el directorio /home/git/.ssh en el host se monta como un volumen en el contenedor, lo que significa que el contenido se comparte entre ellos. Cuando se recibe una conexión al host a través de git sobre SSH, utilizará las mismas authorized_keys archivo como contenedor.

Creando el SSH Shim Script

El paso final para la corrección es crear un stub gitea comando en el host. Esto es lo que permite que los comandos de git funcionen sobre SSH:cuando se realiza una conexión SSH, se ejecutará un comando predeterminado. Esta gitea El comando en el host es lo que representará la conexión SSH al contenedor.

Para este script, use cat escribir en el archivo /usr/local/bin/gitea :

cat <<"EOF" | sudo tee /usr/local/bin/gitea
#!/bin/sh
ssh -p 2222 -o StrictHostKeyChecking=no [email protected] "SSH_ORIGINAL_COMMAND=\"$SSH_ORIGINAL_COMMAND\" $0 $@"
EOF

El comando en este script SSH al contenedor Gitea Docker, pasando el contenido del comando original usado por git .

Finalmente, asegúrese de que el script sea ejecutable:

sudo chmod +x /usr/local/bin/gitea

Prueba de conexiones Git SSH

Puede probar extraer y enviar a los repositorios de Git en su instancia de Gitea agregando su clave SSH a su usuario de Gitea.

Necesitará el contenido de su clave pública SSH. Esto generalmente vive en un archivo llamado algo así como ~/.ssh/id_rsa.pub , según el algoritmo que haya utilizado al crear su clave:

cat ~/.ssh/id_rsa.pub

Nota: Si necesita crear una clave SSH por primera vez, puede aprender cómo hacerlo con este tutorial Cómo configurar claves SSH en Ubuntu 20.04.

Copie la salida de este comando.

En Gitea, haz clic en tu icono de usuario en la esquina superior derecha y selecciona Configuración . En la página de configuración, habrá una serie de pestañas en la parte superior. Haga clic en Claves SSH/GPG , luego Agregar clave botón junto a Administrar claves SSH . Pegue su clave en el área de texto grande del formulario y luego haga clic en Agregar clave botón debajo.

Ahora, navegue hasta el repositorio de prueba que creó en el Paso 3 y copie la URL de SSH provista. En su máquina local, clone el repositorio:

git clone git@your_domain:username/test

Esto usará SSH para clonar el repositorio. Si tiene una contraseña establecida en su clave SSH, se le pedirá que la proporcione.

Vaya a ese directorio, cree un nuevo archivo:

cd test
touch just_testing

A continuación, agréguelo a sus cambios por etapas:

git add just_testing

Finalmente, confirme ese archivo:

git commit -am "Just testing pushing over SSH!"

Ahora, debería poder enviar sus cambios al repositorio remoto:

git push origin master

Cuando actualice la página en su navegador, su nuevo archivo aparecerá en el repositorio.

Conclusión

Configuró un servicio de Gitea usando Docker para hospedar sus repositorios de código fuente. Desde aquí, podrá trabajar en repositorios públicos y privados, utilizando flujos de trabajo familiares, como revisiones de código de solicitud de extracción y proyectos organizados por organización. Gitea también funciona bien con varias herramientas de integración y despliegue continuo (CI/CD) como Drone, Jenkins y GoCD. Además, el uso de volúmenes de Docker como este le permite ampliar su almacenamiento para adaptarse al contenido de Git LFS (almacenamiento de archivos grandes) en la red o bloquear el almacenamiento.