So installierst du Gitea Code Hosting mit Docker auf Rocky Linux 8

Gitea ist ein selbstgehosteter Code-Hosting-Dienst, ähnlich wie Github, Bitbucket und Gitlab. Er 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. Da es eine leichtgewichtige Anwendung ist, kann sie mit minimalen Hardware-Anforderungen installiert werden. Sie enthält einen Editor für Repository-Dateien, einen OpenSSH-Server, Issue Tracking, Pull Requests, Benutzerverwaltung, Benachrichtigungen, ein integriertes Wiki, LFS-Unterstützung, Git Hooks und vieles mehr.

In diesem Artikel lernst du, wie du Gitea mit Docker auf einem Rocky Linux 8 Server installierst.

Voraussetzungen

• Ein Server, auf dem Rocky Linux 8.5 läuft.
• Ein Nicht-Root-Benutzer mit sudo-Rechten.
• Deaktiviere SELinux.
• Aktualisiere alles.

  $ sudo dnf update
  

• Installiere wichtige Pakete.

  $ sudo dnf install yum-utils nano curl
  

• Einen voll qualifizierten Domainnamen (FQDN), der auf den Server zeigt, z. B. gitea.example.com.

Schritt 1 – Firewall konfigurieren

Der erste Schritt besteht darin, die Firewall zu konfigurieren. Rocky Linux verwendet die Firewalld Firewall. Überprüfe den Status der Firewall.

$ sudo firewall-cmd --state
running

Die Firewall arbeitet mit verschiedenen Zonen, wobei die öffentliche Zone die Standardzone ist, die wir verwenden werden. Liste alle Dienste und Ports auf, die auf der Firewall aktiv sind.

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

Es sollte die folgende Ausgabe angezeigt werden.

cockpit dhcpv6-client ssh

Erlaube HTTP- und HTTPS-Ports.

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

Öffne Port 2221 für SSH.

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

Liste alle Dienste auf, die von der Firewall aktiviert werden.

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

Du solltest eine ähnliche Ausgabe sehen.

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

Lade die Firewall neu, um die Änderungen zu aktivieren.

$ sudo firewall-cmd --reload

Schritt 2 – Docker installieren

Rocky Linux wird mit einer älteren Version von Docker ausgeliefert. Um die neueste Version zu installieren, installierst du zuerst das offizielle Docker-Repository.

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

Installiere die neueste Version von Docker.

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

Aktiviere den Docker-Daemon und starte ihn.

$ sudo systemctl enable docker --now

Überprüfe, ob er läuft.

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

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.

Schritt 3 – Installiere Docker Compose

Lade die neueste stabile Version von Docker Compose herunter.

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

Gib der Docker Compose Binärdatei die Berechtigung zum Ausführen.

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

Teste die Installation.

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

Installiere das Docker-Compose Bash Completion Script.

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

Lade deine Profileinstellungen neu, damit die Bash-Vervollständigung funktioniert.

$ source ~/.bashrc

Schritt 4 – Gitea konfigurieren und installieren

Systemzeitzone konfigurieren

Du kannst die aktuelle Zeitzone deines Systems mit dem folgenden Befehl überprüfen.

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

Du kannst sehen, dass das System auf die GMT- oder UTC-Zeitzone 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: Mon 2022-05-02 12:09:23 IST
           Universal time: Mon 2022-05-02 06:39:23 UTC
                 RTC time: Mon 2022-05-02 06:39:22
                Time zone: Asia/Kolkata (IST, +0530)
System clock synchronized: yes
              NTP service: active
          RTC in local TZ: no

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

Erhalte die UID (User Identifier) und GID (Group Identifier) Werte für den aktuell angemeldeten Benutzer. Der erste Befehl generiert die UID, während der zweite die GID ermittelt. Kopiere beide Werte, denn sie werden für die Konfiguration der Docker Compose-Datei benötigt.

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

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.

version: "3"

networks:
  gitea:
    external: false

services:
  server:
    image: gitea/gitea:1.16.6
    container_name: gitea
    environment:
      - USER_UID=1000
      - USER_GID=1000
      - GITEA__database__DB_TYPE=postgres
      - GITEA__database__HOST=db:5432
      - GITEA__database__NAME=gitea
      - GITEA__database__USER=gitea
      - GITEA__database__PASSWD=gitea
    restart: always
    networks:
      - gitea
    volumes:
      - ./gitea:/data
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "3000:3000"
      - "2221:22"
    depends_on:
      - db

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

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

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 Benutzer-ID, die in der Compose-Datei angegeben ist, wird vom Gitea-Container verwendet, um das Verzeichnis gitea zu erstellen.Der PostgreSQL-Container hingegen wird vom Benutzer systemd-coredump verwaltet, was das Standardverhalten 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
bd06e370c46b   gitea/gitea:1.16.6   "/usr/bin/entrypoint…"   19 minutes ago   Up 19 minutes   0.0.0.0:3000->3000/tcp, :::3000->3000/tcp, 0.0.0.0:2221->22/tcp, :::2221->22/tcp   gitea
3fc6c4bce810   postgres:14          "docker-entrypoint.s…"   19 minutes ago   Up 19 minutes   5432/tcp                                                                           gitea_db_1

Du kannst auch den folgenden Befehl verwenden, um den Status zu überprüfen.

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

Schritt 5 – SSL installieren

Um ein SSL-Zertifikat mit Let’s Encrypt zu installieren, müssen wir das Tool Certbot installieren.

Als erstes musst du das EPEL-Repository herunterladen und installieren.

$ sudo dnf install epel-release

Führe die folgenden Befehle aus, um Certbot zu installieren.

$ sudo dnf install certbot

Erstelle das SSL-Zertifikat.

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

Erstelle ein Challenge-Web-Root-Verzeichnis für die automatische Erneuerung von Let’s Encrypt.

$ sudo mkdir -p /var/lib/letsencrypt

Erstelle einen Cron Job zur Erneuerung des SSL-Zertifikats. Er wird jeden Tag ausgeführt, um das Zertifikat zu überprüfen und bei Bedarf zu erneuern. Erstelle dazu zunächst die Datei /etc/cron.daily/certbot-renew und öffne sie zur Bearbeitung.

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

Füge den folgenden Code ein.

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

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Ändere die Berechtigungen für die Aufgabendatei, um sie ausführbar zu machen.

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

Schritt 6 – Nginx installieren

Wir werden die neueste Version von Nginx installieren. Erstelle und öffne die Datei /etc/yum.repos.d/nginx.repo zum Bearbeiten.

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

Füge die folgenden Zeilen in die Datei ein.

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

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

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Installiere Nginx.

$ sudo dnf install nginx

Überprüfe die Installation.

$ nginx -v
nginx version: nginx/1.20.2

Aktiviere und starte den Nginx-Dienst.

$ sudo systemctl enable nginx --now

Erstelle und öffne die Datei /etc/nginx/conf.d/gitea.conf zur Bearbeitung.

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

Füge den folgenden Code in die Datei ein.

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

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

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

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

    location / {
        client_max_body_size 100M;
        proxy_pass  http://localhost:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Mit der obigen Konfiguration kann Nginx als Proxy-Server fungieren und sich an den Port 3000 auf localhost binden. Um das Hochladen großer Dateien für Git LFS zu ermöglichen, kannst du den Wert der Variable client_max_body_size je nach Bedarf ändern. In unserem Lernprogramm verwenden wir 100 MB als Grenze.

Öffne die Datei /etc/nginx/nginx.conf zum Bearbeiten.

$ 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.

Überprüfe die Syntax der Nginx-Konfigurationsdatei.

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

Starte den Nginx-Dienst neu, um die neue Konfiguration zu aktivieren.

$ sudo systemctl restart nginx

Schritt 7 – 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, wie in der Abbildung gezeigt. 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 ausblenden aktiviert, um mehr Datenschutz zu gewährleisten. 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.

Wähle den Standardzweig für dein Projektarchiv.

Wenn du zufrieden bist, klicke auf die Schaltfläche Repository erstellen, um dein erstes Repository in 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)b

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 ([209.23.11.75]:2221)' can't be established.
ECDSA key fingerprint is SHA256:sN0N4OkpChwuR00xpGZU1mGJrp7ktwHRC7uxGP7Nh08.
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added '[gitea.example.com]:2221,[209.23.11.75]:2221' (ECDSA) to the list of known hosts.
remote: Enumerating objects: 4, done.
remote: Counting objects: 100% (4/4), done.
remote: Compressing objects: 100% (3/3), done.
remote: Total 4 (delta 0), reused 0 (delta 0), pack-reused 0
Receiving objects: 100% (4/4), done.

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 Projektarchivs. Hierfür solltest du Git auf deinem lokalen PC installiert haben.

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

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 master
Your branch is up to date with 'origin/master'.

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

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

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."
[master 5e9b039] Update the Readme file for Gitea tutorial.
 1 file changed, 3 insertions(+), 1 deletion(-)

Pushe die Datei auf deinen Gitea Server.

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

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-Nachricht 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 aktualisieren

Das Upgrade von Gitea ist ein einfacher Prozess.

Schließe die bestehenden 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 Rocky Linux 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.