Reverse Proxy für Gitea konfigurieren

Ein Reverse Proxy liefert eine Ressource, welche er von einem oder mehreren Servern holt, an einen Client aus. Bei Gitea kann es durchaus sinnvoll sein, dieses hinter einem Reverse Proxy zu betreiben. Standardmäßig läuft der Dienst auf dem Port 3000. Möchte der Nutzer ihn über die normalen Ports für HTTP (80) bzw. HTTPS (443) erreichbar machen, könnte das Ganze durchaus über die Konfiguration von Gitea in Verbindung mit der systemd-Unit geschehen.

Allerdings ist ein weiterer Vorteil bei einem Reverse Proxy, das die angefragte Infrastruktur aus der Sicht der Clients versteckt wird. Mittels Nginx kann es solcher Reverse Proxy realisiert werden. Dazu muss die Nginx-Konfiguration für die Domain angepasst werden:

nano /etc/nginx/sites-available/example

In diesem Fall befasst sich die Konfiguration mit der verschlüsselten Kommunikation per HTTPS und der Weiterleitung von unverschlüsselten Verbindung in Richtung der verschlüsselten Verbindung.

server {
  listen 80;
  listen [::]:80;

  server_name example.org;

  return 301 https://$host$request_uri$is_args$args;
}

server {
  listen 443;
  listen [::]:443 default_server;

  ssl on;
  ssl_certificate        /etc/letsencrypt/live/example.org/fullchain.pem;
  ssl_certificate_key    /etc/letsencrypt/live/example.org/privkey.pem;

    server_name org;

    location / {
        proxy_pass http://localhost:3000;
    }
}

Anhand der Konfiguration wird ersichtlich das Gitea auf dem Server unverschlüsselt betrieben werden kann, da die eigentliche Verschlüsselung über HTTPS vom Reverse Proxy, in diesem Fall Nginx, übernommen wird. Nachdem die Konfiguration gespeichert wurde, muss Nginx neugestartet werden:

service nginx restart

Anschließend muss die Gitea-Konfiguration nochmals angepasst werden:

nano /home/git/gitea/custom/conf/app.ini

Dort muss die ROOT_URL nun so definiert werden, wie der Client sie nun sieht. Die ROOT_URL kann von:

ROOT_URL         = https://example.org:3000/

zu:

ROOT_URL         = http://example.org/

geändert werden. Die Werte PROTOCOL, CERT_FILE und KEY_FILE können entfernt werden, da die Verschlüsslung nun von Nginx übernommen wird. Nach der Änderung der Konfiguration muss Gitea ebenfalls neugestartet werden:

service gitea restart

Nachdem die Konfiguration durch geführt wurde, ist Gitea unter zwei URLs erreichbar:

http://example.org:3000/
https://example.org/

Intern läuft Gitea auf dem Port 3000. Damit dieser nicht von außen erreichbar ist, sollte eine entsprechende Firewall-Regel konfiguriert werden.

HTTPS für Gitea aktivieren

Nach der Installation von Gitea läuft dieses standardmäßig über unverschlüsseltes HTTP. Um dies zu ändern muss die app.ini welche sich im Verzeichnis /home/git/gitea/custom/conf/ befindet bearbeitet werden:

nano /home/git/gitea/custom/conf/app.ini

In der Sektion server welche für gewöhnlich wie folgt aussieht:

[server]
SSH_DOMAIN       = localhost
DOMAIN           = localhost
HTTP_PORT        = 3000
ROOT_URL         = http://example.org:3000/
DISABLE_SSH      = false
SSH_PORT         = 22
LFS_START_SERVER = true
LFS_CONTENT_PATH = /home/git/gitea/data/lfs
LFS_JWT_SECRET   = plgd0f1J4RlmWFnk9K4oHeV6Wey_vI55x7uC81Rp5Mc
OFFLINE_MODE     = false

müssen einige Änderungen vorgenommen werden. Die Schlüssel PROTOCOL, CERT_FILE und KEY_FILE müssen hinzugefügt und die ROOT_URL angepasst werden. Danach sollte die server-Sektion in etwa so aussehen:

[server]
SSH_DOMAIN       = localhost
DOMAIN           = localhost
HTTP_PORT        = 3000
PROTOCOL         = https
CERT_FILE        = custom/https/cert.pem
KEY_FILE         = custom/https/key.pem
ROOT_URL         = https://example.org:3000/
DISABLE_SSH      = false
SSH_PORT         = 22
LFS_START_SERVER = true
LFS_CONTENT_PATH = /home/git/gitea/data/lfs
LFS_JWT_SECRET   = plgd0f1J4RlmWFnk9K4oHeV6Wey_vI55x7uC81Rp5Mc
OFFLINE_MODE     = false

Nachdem die Konfiguration gespeichert wurde muss das passende Zertifikat erzeugt werden:

cd /home/git/gitea/custom/
mkdir https
cd https
./gitea cert -ca=true -duration=8760h0m0s -host=example.org

Alternativ und in den meisten Fall sinnvoller ist es allerdings an dieser Stelle Zertifikate von Let’s Encrypt einzubinden. Dazu müssen die Zertifikate für die Domain im ersten Schritt erzeugt werden:

letsencrypt certonly

Anschließend muss die app.ini angepasst werden:

nano /home/git/gitea/custom/conf/app.ini

Dort werden die Werte für CERT_FILE und KEY_FILE so konfiguriert das sie auf die Let’s Encrypt-Zertifikate zeigen:

CERT_FILE    = /etc/letsencrypt/live/example.org/fullchain.pem
KEY_FILE     = /etc/letsencrypt/live/example.org/privkey.pem

Damit ist Gitea nach einem Neustart des Service per HTTPS und damit verschlüsselt erreichbar.

Gitea installieren

Vor ein paar Jahren schrieb ich eine Anleitung, in der es darum ging Gogs zu installieren. Schon damals hatte sich eine Abspaltung unter dem Namen Gitea herausgelöst, welche einen Community zentrierten Ansatz bei der Entwicklung fuhr. Gitea ist eine vollwertige Lösung, welche einen Git-Server, eine Weboberfläche und weitere Entwicklerwerkzeuge, wie einen Bugtracker und eine Wiki bereitstellt.

Gitea

Zur Installation von Gitea muss im ersten Schritt Git installiert werden:

apt-get install git

Nachdem dies geschehen ist, wird ein Nutzer für Gitea angelegt und in dessen Kontext gewechselt:

adduser --disabled-password --gecos "" git
su git
cd

Nun kann Gitea heruntergeladen werden. Dazu muss der passende Download-Link über die Projektseite ermittelt werden:

wget https://dl.gitea.io/gitea/1.8.3/gitea-1.8.3-linux-amd64

Im Normalfall sollte hierbei die Linux-AMD64-Version genutzt werden. Nach dem Download kann Gitea für den ersten Testlauf gestartet werden:

mkdir gitea
mv gitea-1.8.3-linux-amd64 gitea/gitea
cd gitea
chmod 755 gitea
./gitea

Nach dem Start kann Gitea im Browser unter der URL aufgerufen werden:

http://example.org:3000/

Sobald der erste Testlauf erfolgreich durchgeführt wurde, sollte Gitea wieder beendet werden. Im nächsten Schritt muss die systemd-Unit eingerichtet werden, welche dafür sorgt, dass der Service automatisch gestartet wird. Dazu wird im ersten Schritt die entsprechende Datei angelegt:

nano /etc/systemd/system/gitea.service

Diese Datei wird nun mit folgendem Inhalt befüllt:

[Unit]
Description=Gitea (Git with a cup of tea)
After=syslog.target
After=network.target
#After=mysqld.service
#After=postgresql.service
#After=memcached.service
#After=redis.service

[Service]
# Modify these two values and uncomment them if you have
# repos with lots of files and get an HTTP error 500 because
# of that
###
#LimitMEMLOCK=infinity
#LimitNOFILE=65535

Type=simple
User=git
Group=git
WorkingDirectory=/home/git/gitea
ExecStart=/home/git/gitea/gitea web
Restart=always
Environment=USER=git HOME=/home/git

# If you want to bind Gitea to a port below 1024 uncomment
# the two values below
###
#CapabilityBoundingSet=CAP_NET_BIND_SERVICE
#AmbientCapabilities=CAP_NET_BIND_SERVICE

[Install]
WantedBy=multi-user.target

Nachdem die systemd-Unit angelegt wurde, kann sie aktiviert und gestartet werden:

systemctl enable gitea
systemctl start gitea

Damit wird Gitea automatisch gestartet und läuft als Service im Hintergrund. Im Browser kann Gitea nun aufgerufen werden und installiert werden. Dazu wird der Anmelden-Button in der Weboberfläche gedrückt oder alternativ die URL:

http://example.org:3000/install

aufgerufen. In der Installationsroutine wird unter anderem die Datenbank-Verbindung definiert und es besteht die Möglichkeit einen administrativen Nutzer anzulegen. Für kleinere Installation kann SQLite3 als Datenbank-Backend bedenkenlos genutzt werden.

Sollten Fehler bei der Installation des Services oder bei Gitea aufgetreten sein, so lohnt es sich in das systemd-Log mittels:

systemctl status gitea

hineinzuschauen. Das Gitea-eigenen Logs befindet sich bei dieser Installation unter /home/git/gitea/log/:

/home/git/gitea/log/gitea.log 
/home/git/gitea/log/http.log 
/home/git/gitea/log/xorm.log

Swift im Browser ausprobieren

Swift ist der freie Nachfolger der Sprache Objective-C und wird unter anderem für die App-Entwicklung unter macOS und iOS genutzt. Daneben kann Swift auch unter anderen Systemen wie Linux genutzt werden. Wer Swift im Browser testen möchte, kann dies mit dem Online Swift Playground tun.

swiftplayground.run

Mit der Nutzung der lokalen Versionen können auch eigene Packages eingebunden werden. Zu finden ist der Online Swift Playground unter online.swiftplayground.run. Der Quelltext ist auf GitHub zu finden, allerdings ist dieser unter der Creative Commons CC-BY-NC lizenziert und damit keine freie Software.

Mapcrafter unter Ubuntu aufsetzen

Eine Welt in Minecraft hat die Angewohnheit, mit der Zeit immer größer zu werden. In einem solchen Fall ist eine Karte natürlich sehr praktisch. Mithilfe des Tools Mapcrafter kann eine solche Karte erstellt werden. Der Mapcrafter erzeugt neben den Kartenkacheln auch eine JavaScript-Anwendung, mit der diese betrachtet werden können.

Eine Mapcrafter-Karte

Im ers­ten Schritt muss das Mapcrafter-Repository mittels:

git clone https://github.com/mapcrafter/mapcrafter.git

auf den Ser­ver geholt werden. Mit dem Befehl wird das Git-Repository, in welchem sich der Quelltext befindet, auf den Server geklont. Im Git-Kontext bedeutet dies, dass das gesamte Repository heruntergeladen wird. Falls Git nicht installiert ist, muss das entsprechende Paket mittels:

apt install git

installiert werden. Die aktuelle Entwicklung findet im Branch world113 statt, so das in diesen gewechselt werden muss:

cd mapcrafter
git checkout world113

Bevor die Software kompiliert werden kann, müssen einige Abhängigkeiten installiert werden:

apt install build-essential cmake libboost-all-dev libjpeg-dev libpng-dev

Anschließen kann die Software kompiliert und installiert werden:

cmake .
make 
make install
ldconfig

Nach der Installation könnte Mapcrafter über den Befehl:

/usr/local/bin/mapcrafter -c example.conf -b -j 4

ausgeführt werden. Allerdings muss vor dem ersten Start noch eine Konfigurationsdatei erstellt werden. In dieser Konfigurationsdatei ist definiert, wie die Karte gerendert werden soll. Die Datei und die Skripte zur Aktualisierung werden im Kontext des Nutzers minecraft angelegt:

su minecraft
cd
mkdir map
nano example.conf

Exemplarisch könnte die Konfigurationsdatei wie folgt aussehen:

output_dir = /home minecraft/map
background_color = #000000

[marker:teleporter]
name = Teleporter
prefix = Hauptteleporter
icon = beacon.png
icon_size = [32, 32]
show_default = false
title_format = %(textp)

[marker:signs]
name = Signs
icon = sign.png
icon_size = [32, 32]
show_default = false
title_format = %(textp)

[world:world]
input_dir = world
world_name = Example

[global:map]
image_format = png
png_indexed = true
rotations = top-left
texture_size = 16

[map:day_isometric]
name = Day (isometric)
render_view = isometric
render_mode = daylight
world = world

Nachdem die Konfigurationsdatei angelegt wurde, kann die Karte testweise mittels des Befehls:

/usr/local/bin/mapcrafter -c example.conf -b -j 4

erzeugt werden. Damit die Aktualisierung später automatisch geschieht, werden die Befehle zur Aktualisierung der Skripte in eine Skript-Datei geschrieben:

nano updateMap.sh

Diese Datei wird mit folgendem Inhalt befüllt:

#!/bin/bash
/usr/local/bin/mapcrafter -c example.conf -b -j 4
/usr/local/bin/mapcrafter_markers -v -c example.conf

Anschließend soll ein Cronjob eingerichtet werden. Dazu wird der Crontab-Editor geöffnet:

crontab -e

In der sich öffnende Datei muss nun folgende Zeile hinzugefügt werden:

0    1    * * *   (. ~/.profile; /usr/bin/screen -dmS mapcrafter /home/minecraft/updateMap.sh)

Danach kann die Datei geschlossen werden. Der Cronjob startet nun um 1 Uhr die tägliche Aktualisierung der Karte.