So installierst du die Gitea DevOps-Plattform mit Docker unter Debian 12
Gitea ist eine Open-Source-Code-Hosting-Lösung, die auf der Git-Plattform basiert. Sie ist in der Sprache Go geschrieben und kann auf mehreren Betriebssystemen installiert werden, darunter Linux, macOS, Windows und Architekturen wie amd64, i386, ARM und andere. Es enthält einen Editor für Repository-Dateien, Issue Tracking, Pull Requests, Benutzerverwaltung, Benachrichtigungen, ein integriertes Wiki, LFS Support, Git Hooks und vieles mehr.
Es ist eine leichtgewichtige Anwendung. Daher kann sie auch auf Systemen mit geringerer Leistung installiert werden. Wenn du auf der Suche nach einer selbst gehosteten Git-Plattform mit weniger Speicherplatz bist, solltest du dir Gitea ansehen.
Dieser Artikel behandelt die Installation und Konfiguration von Gitea auf einem Debian 12-Server und die Einrichtung deines ersten Git-Repositorys. Gitea kann aus dem Quellcode, als Binärdatei, als Docker-Paket oder als Paket installiert werden. Für unser Tutorial werden wir es mit Docker installieren.
Voraussetzungen
- Ein Server, auf dem Debian 12 läuft.
- Ein Nicht-Root-Benutzer mit sudo-Rechten.
- Ein Fully Qualified Domain Name (FQDN) wie
gitea.example.com, der auf deinen Server zeigt. - Vergewissere dich, dass auf deinem Server Auslagerungsspeicher aktiviert ist, wenn du einen Server mit 1 GB RAM verwendest.
- Stelle sicher, dass alles auf dem neuesten Stand ist.
$ sudo apt update && sudo apt upgrade
- Bevor wir fortfahren, benötigen wir ein paar wichtige Pakete. Einige davon werden bereits auf deinem Server installiert sein.
$ sudo apt install curl wget nano software-properties-common dirmngr apt-transport-https ca-certificates lsb-release debian-archive-keyring gnupg2 ufw unzip -y
Schritt 1 – Firewall konfigurieren
Der erste Schritt besteht darin, die Firewall zu konfigurieren. Debian wird standardmäßig mit ufw (Uncomplicated Firewall) ausgeliefert.
Überprüfe, ob die Firewall aktiv ist.
$ sudo ufw status
Du wirst die folgende Ausgabe erhalten.
Status: inactive
Erlaube den SSH-Port, damit die Firewall die aktuelle Verbindung nicht unterbricht, wenn du sie aktivierst.
$ sudo ufw allow OpenSSH
Lasse auch HTTP- und HTTPS-Ports zu.
$ sudo ufw allow http $ sudo ufw allow https
Aktiviere die Firewall
$ sudo ufw enable Command may disrupt existing ssh connections. Proceed with operation (y|n)? y Firewall is active and enabled on system startup
Überprüfe den Status der Firewall erneut.
$ sudo ufw status
Du solltest eine ähnliche Ausgabe sehen.
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)
Schritt 2 – Installiere Docker und Docker Compose
Debian 12 wird mit einer älteren Version von Docker ausgeliefert. Um die neueste Version zu installieren, importiere zunächst den Docker GPG-Schlüssel.
$ curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker.gpg
Erstelle eine Docker-Repository-Datei.
$ 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
Aktualisiere die Liste der System-Repositorys.
$ sudo apt update
Installiere die neueste Version von Docker.
$ sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
Überprüfe, ob sie läuft.
$ 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
Standardmäßig benötigt Docker Root-Rechte. Wenn du vermeiden willst, dass du jedes Mal sudo verwendest, wenn du den Befehl docker ausführst, füge deinen Benutzernamen der Gruppe docker hinzu.
$ sudo usermod -aG docker $(whoami)
Um diese Änderung zu aktivieren, musst du dich vom Server abmelden und als derselbe Benutzer wieder anmelden oder den folgenden Befehl verwenden.
$ su - ${USER}
Bestätige, dass dein Benutzer der Docker-Gruppe hinzugefügt wurde.
$ groups navjot sudo users docker
Schritt 3 – Einen Git-Benutzer erstellen
Damit die Benutzer über SSH auf den Host zugreifen können, musst du einen separaten git Benutzer auf dem Host erstellen. Führe den folgenden Befehl aus, um den Benutzer git zu erstellen.
$ sudo adduser --system --shell /bin/bash --gecos 'Git Version Control' --group --disabled-password --home /home/git git
Zum besseren Verständnis gehen wir alle Optionen und Flags des obigen Befehls durch.
--system– erstellt einen Systembenutzer anstelle eines normalen Benutzers. Systembenutzer sind für die Ausführung von Systemdiensten vorgesehen und können nicht für interaktive Anmeldungen verwendet werden.--shell /bin/bash– setzt die Anmeldeshell für den Systembenutzer auf die Bash-Shell.--gecos 'Git Version Control'– legt ein Beschreibungsfeld für den Benutzer fest. Es ist optional und kann übersprungen werden, ist aber nützlich, wenn dein System viele Benutzer hat.--group– erstellt eine Gruppe mit demselben Namen wie der Benutzer.--disabled-password– deaktiviert die passwortbasierte Anmeldung für den Benutzer, was zur Sicherheit des Kontos beiträgt.--home /home/git– setzt das Heimatverzeichnis des Benutzers auf/home/git, in dem die Dateien und die Konfiguration des Benutzers gespeichert werden.git– gibt den Benutzernamen an. Hier verwenden wirgitals Benutzernamen für das Konto.
Wenn du den Befehl ausführst, erhältst du die folgende Ausgabe.
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' ...
Beachte die Werte der Variablen UID und GID, die wir im nächsten Schritt benötigen. In unserem Fall ist die UID 105 und die GID 111.
Schritt 4 – Gitea konfigurieren und installieren
Systemzeitzone konfigurieren
Du kannst die aktuelle Zeitzone deines Systems mit dem folgenden Befehl überprüfen.
$ 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
Du kannst sehen, dass das System auf die Zeitzone GMT oder UTC eingestellt ist. Wenn du in einem Gebiet mit einer anderen Zeitzone lebst oder sie ändern möchtest, kannst du das mit dem folgenden Befehl tun.
$ sudo timedatectl set-timezone Asia/Kolkata
Überprüfe die Zeitzone erneut.
$ 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
Du kannst sehen, dass die Zeitzone auf IST aktualisiert wurde, was GMT+5:30 entspricht.
Gitea-Verzeichnisse erstellen
Erstelle das Verzeichnis für Gitea.
$ mkdir ~/gitea-docker
Wechsle in das Gitea-Verzeichnis.
$ cd ~/gitea-docker
Erstelle Verzeichnisse für die Speicherung von Gitea-Daten und PostgreSQL-Datenbanken.
$ mkdir {gitea,postgres}
Konfiguriere die Gitea Docker Compose Datei
Erstelle und öffne die Docker Compose Datei zur Bearbeitung.
$ nano docker-compose.yml
Füge den folgenden Code in die Datei ein. Füge die zuvor erstellten UID- und GID-Werte ein.
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
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Wir verwenden die UID- (User Identifier) und GID- (Group Identifier) Werte für den Benutzer, den wir im vorherigen Schritt erstellt haben.
Die obige Docker Compose-Datei stellt zwei Container bereit – einen für Gitea und einen für PostgreSQL. Wir haben ein paar Umgebungsvariablen hinzugefügt, um die Details der Datenbank zu konfigurieren. Um die PostgreSQL-Datenbank mit dem Gitea-Container zu verbinden, haben wir den Host als Namen des PostgreSQL-Dienstes in der Datei angegeben.
Die Port-Parameter "3000:3000" und "2221:22" geben die Port-Zuordnung an, wobei der linke Port den Host-Port und der rechte Port den Container-Port bezeichnet. Gitea verwendet den Port 3000 für seinen Webservice, den wir auch dem Server zur Verfügung gestellt haben. Für SSH verwendet unser System bereits Port 22 für die Protokollierung. Deshalb geben wir einen eigenen Port an, um SSH-Operationen durchzuführen. In unserem Fall verwenden wir Port 2221. Dieser Port muss ebenfalls über deine Firewall geöffnet werden, was wir bereits in Schritt 1 dieses Lernprogramms getan haben.
Sowohl Gitea als auch die PostgreSQL-Container sind über ein gemeinsames internes Docker-Netzwerk namens gitea verbunden. Wenn du deine Docker-Installation startest, werden automatisch die Verzeichnisse gitea und postgres im aktuellen Ordner angelegt. Die in der Compose-Datei angegebene Benutzer-ID ist diejenige, die der Gitea-Container verwendet, um das Verzeichnis gitea zu erstellen. Der PostgreSQL-Container hingegen wird vom Benutzer systemd-coredump verwaltet, was die Standardeinstellung ist. Du kannst dieses Verhalten ändern, aber es ist nicht notwendig.
Anpassen deiner Gitea-Installation
Du kannst deine Gitea-Installation anpassen, indem du eine app.ini-Datei in das Verzeichnis ~/gitea-docker/gitea/gitea/conf einfügst. Nach der Installation kann diese Datei innerhalb des Containers unter /data/gitea/conf/app.ini bearbeitet werden. Du kannst die Beispiel-ini-Datei aus dem Github-Repository von Gitea als Referenz verwenden.
Gitea installieren
Führe den folgenden Befehl aus, um die Gitea-Container zu starten.
$ docker compose up -d
Überprüfe den Status der Container, um sicherzustellen, dass sie ordnungsgemäß laufen.
$ 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
Du kannst auch den folgenden Befehl verwenden, um den Status zu überprüfen.
$ 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
Schritt 5 – Nginx installieren
Debian 12 wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das offizielle Nginx-Repository herunterladen.
Importiere den Signierschlüssel von Nginx.
$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
Füge das Repository für die stabile Version von Nginx hinzu.
$ 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
Aktualisiere die System-Repositories.
$ sudo apt update
Installiere Nginx.
$ sudo apt install nginx
Überprüfe die Installation. Auf Debian-Systemen funktioniert der folgende Befehl nur mit sudo.
$ sudo nginx -v nginx version: nginx/1.24.0
Starten Sie den Nginx-Server.
$ sudo systemctl start nginx
Überprüfe den Status des Dienstes.
$ 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"
Öffne die IP-Adresse deines Servers in deinem Webbrowser. Du solltest die folgende Seite sehen, d.h. dein Server ist in Betrieb.
Schritt 6 – SSL installieren
Wir müssen Certbot installieren, um das SSL-Zertifikat zu erstellen. Du kannst Certbot entweder über das Repository von Debian installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.
Bei Debian 12 ist Snapd noch nicht installiert. Installiere das Snapd-Paket.
$ sudo apt install snapd
Führe die folgenden Befehle aus, um sicherzustellen, dass deine Version von Snapd auf dem neuesten Stand ist.
$ sudo snap install core && sudo snap refresh core
Installiere Certbot.
$ sudo snap install --classic certbot
Verwende den folgenden Befehl, um sicherzustellen, dass der Certbot-Befehl ausgeführt werden kann, indem du einen symbolischen Link zum Verzeichnis /usr/bin erstellst.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Überprüfe, ob Certbot korrekt funktioniert.
$ certbot --version certbot 2.7.4
Erstelle das SSL-Zertifikat.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d gitea.example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/gitea.example.com auf deinem Server heruntergeladen.
Erstelle ein Diffie-Hellman-Gruppenzertifikat.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Überprüfe den Certbot-Erneuerungszeitplanungsdienst.
$ sudo systemctl list-timers
Du findest snap.certbot.renew.service als einen der Dienste, die für die Ausführung vorgesehen sind.
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
Führe einen Probelauf des Prozesses durch, um zu prüfen, ob die SSL-Erneuerung einwandfrei funktioniert.
$ sudo certbot renew --dry-run
Wenn du keine Fehler siehst, bist du bereit. Dein Zertifikat wird automatisch erneuert.
Schritt 7 – Nginx konfigurieren
Führe den folgenden Befehl aus, um eine Konfigurationsdatei für deine Website hinzuzufügen.
$ sudo nano /etc/nginx/conf.d/gitea.conf
Füge den folgenden Code in den Editor ein.
# 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;
}
}
Wenn du fertig bist, drücke Strg + X, um den Editor zu schließen und drücke Y, wenn du aufgefordert wirst, die Datei zu speichern.
Öffne die Datei /etc/nginx/nginx.conf zur Bearbeitung.
$ sudo nano /etc/nginx/nginx.conf
Füge die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; ein.
server_names_hash_bucket_size 64;
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Teste die Nginx-Konfiguration.
$ sudo nginx -t
Du solltest die folgende Ausgabe sehen, die anzeigt, dass deine Konfiguration korrekt ist.
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok nginx: configuration file /etc/nginx/nginx.conf test is successful
Lade den Nginx-Dienst neu.
$ sudo systemctl reload nginx
Schritt 8 – Zugriff und Einrichtung von Gitea
Rufe die URL https://gitea.example.com in deinem Browser auf und der folgende Installationsbildschirm wird angezeigt.
Die meisten Felder werden auf der Grundlage der Werte aus der Docker Compose-Datei vorausgefüllt.
Gib gitea.example.com als Server Domain und https://gitea.example.com als Gitea Base URL ein. Ändere den Wert für den SSH-Server-Port von 22 auf 2221. Lass die restlichen Einstellungen unverändert.
Wenn du die E-Mail-Funktionen nutzen willst, kannst du die Details deines SMTP-Servers hinzufügen. Erweitere den Abschnitt E-Mail-Einstellungen auf der Seite und gib die Werte wie im Screenshot gezeigt ein. Achte darauf, dass du deinen SMTP-Port zusammen mit dem Hostnamen angibst. Für unser Tutorial verwenden wir den Amazon SES Service. Du kannst jeden SMTP-Dienst deiner Wahl verwenden.
Es gibt noch ein paar weitere Einstellungen, die du vor der Installation überprüfen solltest. Um sie zu ändern, erweitere den Abschnitt Server- und Drittanbieter-Service-Einstellungen auf der Seite.
Ändere die Einstellungen entsprechend deinen Anforderungen. Wir haben die Option E-Mail-Adressen standardmäßig verbergen aktiviert, um mehr Datenschutz zu gewährleisten, und die Option Anmeldung zum Anzeigen von Seiten erforderlich, um unsere Git-Seite privat zu halten. Wenn du nicht möchtest, dass sich jemand ein Konto anlegt, aktiviere die Option Selbstregistrierung deaktivieren.
Zu guter Letzt musst du dein Administratorkonto einrichten. Erweitere den Abschnitt Einstellungen für das Administratorkonto auf der Seite und trage die erforderlichen Werte ein.
Klicke abschließend auf die Schaltfläche Gitea installieren, um die Installation abzuschließen. Du wirst zum Gitea Dashboard weitergeleitet. Wenn du aus irgendeinem Grund eine 502-Fehlermeldung erhältst, aktualisiere die Seite.
Schritt 8 – Erstes Repository erstellen
Lass uns unser erstes Repository erstellen. Klicke dazu auf das + Zeichen im Dashboard.
Gib die Repository-Details ein. Wähle das Label Standardausgabe aus dem Dropdown-Menü. Wähle eine passende Lizenz für dein Projektarchiv aus.
Wähle den Standardzweig für dein Projektarchiv.
Wenn du zufrieden bist, klicke auf die Schaltfläche Repository erstellen, um dein erstes Repository auf deiner Gitea-Installation zu erstellen. Du wirst zur Startseite deines Projektarchivs weitergeleitet.
Schritt 9 – SSH einrichten
Richten wir SSH ein, um es mit unserem neu erstellten Repository zu verwenden.
Für unser Tutorial verwenden wir einen lokalen PC, auf dem Ubuntu vorinstalliert ist. Die Befehle sollten jedoch auf jedem OS-Terminal ohne große Änderungen funktionieren.
Erstelle einen neuen SSH-Schlüssel, den du mit Gitea auf deinem lokalen PC verwenden kannst.
$ ssh-keygen -f ~/.ssh/gitea-demo -t rsa -b 4096 -C "HowtoForge Gitea Demo" -q -N "yourpassphrase"
Gib eine starke Passphrase anstelle des Platzhalters im obigen Befehl ein. Dadurch wird ein SSH-Schlüssel unter ~/.ssh/gitea-demo erstellt.
Als Nächstes öffnest du deine Gitea-Profileinstellungen, indem du auf das Dropdown-Menü deines Profilbildes klickst und die Option Einstellungen auswählst.
Wechsle dann zum Reiter SSH/GPG-Schlüssel auf der Seite.
Füge einen Namen für deinen SSH-Schlüssel hinzu. Gehe zurück zum Terminal auf deinem lokalen PC und führe den folgenden Befehl aus, um den öffentlichen Schlüssel für Gitea auszugeben.
$ cat ~/.ssh/gitea-demo.pub
Kopiere die Ausgabe und füge sie wieder in das Feld Inhalt auf der Seite SSH-Schlüssel von Gitea ein.
Klicke auf die Schaltfläche Schlüssel hinzufügen, um das Hinzufügen des Schlüssels abzuschließen.
Gehe zurück zu deinem lokalen PC und richte den SSH-Agenten so ein, dass er für 1 Stunde aktiv bleibt.
$ eval $(ssh-agent -t 3600)
Füge den neu erstellten SSH-Schlüssel zum SSH-Agenten hinzu.
$ ssh-add ~/.ssh/gitea-demo Enter passphrase for /home/navjot/.ssh/gitea-demo: Identity added: /home/navjot/.ssh/gitea-demo (HowtoForge Gitea Demo)
Du wirst aufgefordert, deine Passphrase einzugeben.
Schritt 10 – Klonen des Repositorys mit SSH
Lass uns das neu erstellte Projektarchiv mit SSH klonen. Besuche die Repository-Seite erneut und kopiere die SSH-URL, nachdem du die Option SSH ausgewählt hast.
Sie sollte wie die folgende aussehen.
ssh://git@gitea.example.com:2221/navjot/howtoforge.git
Führe den folgenden Befehl auf deinem lokalen PC aus, um das Repository mit SSH zu klonen.
$ git clone ssh://git@gitea.example.com: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.
Du wirst aufgefordert, die Host-Zugangsdaten einzugeben. Gib yes ein, um mit dem Klonen des Projektarchivs fortzufahren.
Du wirst das geklonte Projektarchiv auf deinem System sehen.
$ ls howtoforge
Wechsle in das Verzeichnis.
$ cd howtoforge
Überprüfe den Git-Status des neu geklonten Repositorys. Hierfür solltest du Git auf deinem lokalen PC installiert haben.
$ git status On branch main Your branch is up to date with 'origin/main'. nothing to commit, working tree clean
Damit ist klar, dass SSH einwandfrei funktioniert.
Schritt 11 – Testen des ersten Commits
Jetzt, wo wir unser erstes Repository eingerichtet haben, ist es an der Zeit, einige Änderungen vorzunehmen und sie zu committen.
Lass uns die Datei README.md aktualisieren. Öffne auf deinem lokalen PC die Readme-Datei zum Bearbeiten.
$ nano README.md
Bearbeite die Datei und wenn du fertig bist, speichere sie, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Überprüfe erneut den Git-Status.
$ 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")
Dieser zeigt an, dass die Readme-Datei zwar bearbeitet, aber nicht übertragen wurde. Füge die Datei hinzu, um sie für das Commit vorzubereiten.
$ git add README.md
Übertrage die Datei.
$ 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(-)
Pushe die Datei auf deinen Gitea Server.
$ 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
Zur Bestätigung gehst du zurück zur Gitea-Repository-Seite.
Du kannst sehen, dass die Readme-Datei aktualisiert wurde und die letzte Commit-Meldung angezeigt wird. Um die Änderungen zu sehen, klicke auf die Commit-Meldung und du kannst die folgende Seite mit den Unterschieden sehen.
Damit ist unser erster Commit für unser Repository abgeschlossen. Du kannst mit der Arbeit an deiner Gitea Installation für deine Projekte beginnen.
Schritt 12 – Gitea sichern und wiederherstellen
Gitea wird mit einem Kommandozeilentool ausgeliefert, mit dem du mit einem einzigen Befehl ein Backup erstellen kannst. Um das Kommandozeilentool innerhalb des Docker-Containers auszuführen, um ein Backup zu erstellen, führe den folgenden Befehl aus.
$ docker exec -u git -it -w /app/gitea gitea bash -c '/usr/local/bin/gitea dump -c /data/gitea/conf/app.ini'
Wir führen den Befehl mit demselben Benutzer aus, den wir in Schritt 3 angelegt und während der Installation mit dem Flag -u git im obigen Befehl konfiguriert haben. Das Flag -w /app/gitea legt den Ordner innerhalb des Docker-Containers fest, in dem die Backup-Datei gespeichert werden soll. Der Backup-Ordner muss so gewählt werden, dass der Benutzer git die Berechtigung hat, auf ihn zu schreiben. Innerhalb des Docker-Containers gibt es nur zwei solcher Ordner. Der eine ist der Ordner /data und der andere ist der Ordner /app/gitea. Den Ordner /data können wir nicht verwenden, weil das Kommandozeilentool den gesamten Datenordner sichert, was zu einer Endlosschleife führt, wenn wir ihn als Ziel verwenden, was den Speicherplatz deines Servers füllen kann. Deshalb können wir das Backup nur im Ordner /app/gitea speichern.
Der nächste Punkt des Befehls ist der Name des Containers, gitea. Danach geben wir den Typ der Linux-Shell an, die zur Ausführung des Befehls innerhalb des Containers verwendet wird. Das Flag -c gibt den Befehl an, der innerhalb des Containers ausgeführt werden soll. Und der auszuführende Befehl ist /usr/local/bin/gitea dump -c /data/gitea/conf/app.ini, der das Kommandozeilentool ausführt und den Speicherort der dazugehörigen Konfigurationsdatei angibt.
Sobald der Befehl ausgeführt wurde, siehst du die folgende Ausgabe.
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
Lass uns nun den Wiederherstellungsprozess durchlaufen. Du solltest jetzt eine neue Docker-Installation von Gitea haben. Führe aber nicht den Installationsprozess durch.
Melde dich in der Docker-Shell an.
$ docker exec --user git -it gitea bash
Wechsle in das Verzeichnis app/gitea.
$ cd app/gitea
Entpacke die Sicherungsdatei.
$ unzip gitea-dump-1700441501.zip
Wechsle in das entpackte Verzeichnis.
$ cd gitea-dump-1700441501
Stelle den Ordner /data/gitea wieder her.
$ mv data/* /data/gitea
Stelle die Repositories wieder her.
$ mv repos/* /data/git/gitea-repositories/
Korrigiere die Dateiberechtigungen.
$ chown -R git:git /data
Erstelle die Git Hooks neu.
$ /usr/local/bin/gitea -c '/data/gitea/conf/app.ini' admin regenerate hooks
Beende die Docker-Shell.
$ exit
Schritt 13 – Upgrade von Gitea
Das Upgrade von Gitea ist ein einfacher Prozess.
Schließe die vorhandenen Container und entferne sie. Da die Daten außerhalb der Container auf dem Host gespeichert sind, werden sie beibehalten.
$ cd ~/gitea-docker $ docker compose down --remove-orphans
Öffne die Datei docker-compose.yml und ändere die Version des Gitea-Containers. Als nächstes ziehst du das neue Gitea-Image.
$ docker pull
Starten Sie die neuen Container.
$ docker compose up -d
Überprüfe den Status.
$ docker ps
Fazit
Dies ist der Abschluss unseres Tutorials, in dem wir den Gitea Code Hosting Service mit Docker auf einem Debian 12 Server installiert haben. Außerdem haben wir den Nginx-Server installiert, der als Proxy fungiert, und Gitea über eine öffentliche URL mit SSL zugänglich gemacht. Wenn du Fragen hast, schreibe sie unten in die Kommentare.