So installierst du Hugo Site Generator mit Nginx auf Rocky Linux 9
Eine statische Website besteht aus Seiten mit statischem Inhalt oder einfachem HTML-, JavaScript- oder CSS-Code. Die Inhalte werden nicht dynamisch generiert und beinhalten keine Datenbank oder serverseitige Verarbeitung. Solche Websites sind unglaublich schnell und immun gegen Angriffe, die auf dynamischen Code oder SQL angewiesen sind.
Hugo ist ein in Go geschriebener Open-Source-Generator für statische Websites. Er erzeugt Inhalte, indem er in Markdown geschriebene Beiträge in HTML umwandelt. Hugo wird mit einem eingebauten Server geliefert, auf dem die erstellten Websites gehostet werden. Du kannst eine Hugo-Website auch auf Amazon S3, GitHub-Seiten, Google Cloud, Netlify, Vercel, etc. hosten.
In diesem Lernprogramm zeigen wir dir, wie du Hugo installierst, um eine statische Website auf einem Server mit Rocky Linux 9 zu erstellen. Wir verwenden den Nginx-Server, um die Website zu hosten, und das Let’s Encrypt SSL-Zertifikat, um unsere Installation zu sichern.
Voraussetzungen
- Ein Server, auf dem Rocky Linux 9 läuft.
- Ein Nicht-Root-Benutzer mit sudo-Rechten.
- Ein vollständig qualifizierter Domainname (FQDN), der auf deinen Server verweist. Für unsere Zwecke werden wir
hugo.example.comals Domänennamen verwenden. - Stelle sicher, dass alles auf dem neuesten Stand ist.
$ sudo dnf update
- Installiere grundlegende Hilfspakete. Einige von ihnen sind vielleicht schon installiert.
$ sudo dnf install wget curl nano unzip yum-utils tree -y
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
Wiki.js braucht HTTP- und HTTPS-Ports, um zu funktionieren. Öffne sie.
$ sudo firewall-cmd --add-service=http --permanent $ sudo firewall-cmd --add-service=https --permanent
Lade die Firewall neu, um die Änderungen zu übernehmen.
$ sudo firewall-cmd --reload
Schritt 2 – Nginx installieren
Rocky Linux 9 wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das offizielle Nginx-Repository herunterladen.
Erstelle und öffne die Datei /etc/yum.repos.d/nginx.repo zur Erstellung des offiziellen Nginx-Repositorys.
$ sudo nano /etc/yum.repos.d/nginx.repo
Füge den folgenden Code 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 den Nginx-Server.
$ sudo dnf install nginx -y
Überprüfe die Installation.
$ nginx -v nginx version: nginx/1.24.0
Aktiviere und starte den Nginx-Server.
$ sudo systemctl enable nginx --now
Überprüfe den Status des Servers.
$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; preset: disabled)
Active: active (running) since Mon 2023-10-30 08:24:05 UTC; 7s ago
Docs: http://nginx.org/en/docs/
Process: 4265 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
Main PID: 4266 (nginx)
Tasks: 2 (limit: 4402)
Memory: 1.9M
CPU: 7ms
CGroup: /system.slice/nginx.service
??4266 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
??4267 "nginx: worker process"
Oct 30 08:24:05 hugo.example.com systemd[1]: Starting nginx - high performance web server...
Schritt 3 – Git installieren
Hugo braucht Git, um zu funktionieren. Führe den folgenden Befehl aus, um Git zu installieren
$ sudo dnf install git -y
Überprüfe die Installation von Git.
$ git --version git version 2.39.3
Schritt 4 – Installiere Hugo
Da Hugo mit der Sprache Go erstellt wurde, ist die Installation recht einfach, da es keine Abhängigkeiten benötigt und eigenständig ausgeführt werden kann.
Lade Hugo herunter. Für unseren Lehrgang werden wir die erweiterte Version von Hugo installieren. Die erweiterte Version kann Bilder bei der Verarbeitung in das Webp-Format kodieren. Das ist nützlich, wenn du möchtest, dass Hugo Bilder für dich umwandelt und ihre Größe gering hält. Die erweiterte Version enthält auch einen SASS-Compiler, der in bestimmten Fällen nützlich sein kann, falls du ihn brauchst.
Erstelle ein Verzeichnis für Hugo.
$ sudo mkdir /var/www/html/hugo -p
Wechsle in das neu erstellte Verzeichnis.
$ cd /var/www/html/hugo
Lade Hugo von der GitHub-Veröffentlichungsseite herunter. Zum Zeitpunkt der Erstellung dieses Tutorials ist v0.119.0 die neueste Version, die wir herunterladen werden.
$ sudo wget https://github.com/gohugoio/hugo/releases/download/v0.119.0/hugo_extended_0.119.0_linux-amd64.tar.gz
Entpacke die Dateien aus dem Archiv.
$ sudo tar -xzf hugo_extended_0.119.0_linux-amd64.tar.gz
Du wirst die folgenden drei Dateien in deinem Verzeichnis finden.
$ ls hugo hugo_extended_0.119.0_linux-amd64.tar.gz LICENSE README.md
Verschiebe die Binärdatei hugo in das Verzeichnis /usr/bin.
$ sudo mv hugo /usr/bin/hugo
Die Datei hat bereits die Berechtigung „Ausführbar“, du brauchst sie also nicht zu setzen.
Bestätige die Installation.
$ hugo version hugo v0.119.0-b84644c008e0dc2c4b67bd69cccf87a41a03937e+extended linux/amd64 BuildDate=2023-09-24T15:20:17Z VendorInfo=gohugoio
Du kannst auch alle verfügbaren Optionen überprüfen, indem du das Flag --help verwendest.
$ hugo --help
Du erhältst dann die folgende Ausgabe.
hugo is the main command, used to build your Hugo site.
Hugo is a Fast and Flexible Static Site Generator
built with love by spf13 and friends in Go.
Complete documentation is available at https://gohugo.io/.
Usage:
hugo [flags]
hugo [command]
Available Commands:
completion Generate the autocompletion script for the specified shell
config Print the site configuration
convert Convert your content to different formats
deploy Deploy your site to a Cloud provider.
env Print Hugo version and environment info
gen A collection of several useful generators.
help Help about any command
import Import your site from others.
list Listing out various types of content
mod Various Hugo Modules helpers.
new Create new content for your site
server A high performance webserver
version Print Hugo version and environment info
Flags:
-b, --baseURL string hostname (and path) to the root, e.g. https://spf13.com/
-D, --buildDrafts include content marked as draft
-E, --buildExpired include expired content
-F, --buildFuture include content with publishdate in the future
--cacheDir string filesystem path to cache directory
--cleanDestinationDir remove files from destination not found in static directories
--clock string set the clock used by Hugo, e.g. --clock 2021-11-06T22:30:00.00+09:00
--config string config file (default is hugo.yaml|json|toml)
--configDir string config dir (default "config")
-c, --contentDir string filesystem path to content directory
--debug debug output
-d, --destination string filesystem path to write files to
--disableKinds strings disable different kind of pages (home, RSS etc.)
--enableGitInfo add Git revision, date, author, and CODEOWNERS info to the pages
-e, --environment string build environment
--forceSyncStatic copy all files when static is changed.
--gc enable to run some cleanup tasks (remove unused cache files) after the build
-h, --help help for hugo
--ignoreCache ignores the cache directory
--ignoreVendorPaths string ignores any _vendor for module paths matching the given Glob pattern
-l, --layoutDir string filesystem path to layout directory
--logLevel string log level (debug|info|warn|error)
--minify minify any supported output format (HTML, XML etc.)
--noBuildLock don't create .hugo_build.lock file
--noChmod don't sync permission mode of files
--noTimes don't sync modification time of files
--panicOnWarning panic on first WARNING log
--poll string set this to a poll interval, e.g --poll 700ms, to use a poll based approach to watch for file system changes
--printI18nWarnings print missing translations
--printMemoryUsage print memory usage to screen at intervals
--printPathWarnings print warnings on duplicate target paths etc.
--printUnusedTemplates print warnings on unused templates.
--quiet build in quiet mode
--renderToMemory render to memory (only useful for benchmark testing)
-s, --source string filesystem path to read files relative from
--templateMetrics display metrics about template executions
--templateMetricsHints calculate some improvement hints when combined with --templateMetrics
-t, --theme strings themes to use (located in /themes/THEMENAME/)
--themesDir string filesystem path to themes directory
--trace file write trace to file (not useful in general)
-v, --verbose verbose output
-w, --watch watch filesystem for changes and recreate as needed
Use "hugo [command] --help" for more information about a command.
Lösche alle übrigen Dateien in dem Ordner, da sie nicht mehr benötigt werden.
$ sudo rm -rf *.*
Schritt 5 – Erstellen einer neuen Hugo-Site
Gib den folgenden Befehl ein, um eine neue Hugo-Website zu erstellen.
$ sudo hugo new site howtoforge
Du erhältst die folgende Ausgabe.
Congratulations! Your new Hugo site was created in /home/navjot/hugo/howtoforge. Just a few more steps... 1. Change the current directory to /home/navjot/hugo/howtoforge. 2. Create or install a theme: - Create a new theme with the command "hugo new theme <THEMENAME>" - Install a theme from https://themes.gohugo.io/ 3. Edit hugo.toml, setting the "theme" property to the theme name. 4. Create new content with the command "hugo new content <SECTIONNAME>/<FILENAME>.<FORMAT>". 5. Start the embedded web server with the command "hugo server --buildDrafts". See documentation at https://gohugo.io/.
Führe den Befehl tree aus, um die Struktur der Website zu überprüfen.
$ tree howtoforge/
Du erhältst die folgende Ausgabe.
howtoforge/ ??? archetypes ? ??? default.md ??? assets ??? content ??? data ??? hugo.toml ??? i18n ??? layouts ??? static ??? themes 8 directories, 2 files
Wechsle in das Hugo-Verzeichnis.
$ cd howtoforge
Schritt 6 – Hugo-Theme installieren
Der nächste Schritt besteht darin, ein Hugo-Theme zu installieren. Dafür gibt es zwei Möglichkeiten, und beide erfordern Git. Die erste Methode ist schlicht und einfach und beinhaltet das Klonen des GitHub-Repositorys des Themes. Das ist in den meisten Fällen sinnvoll und der einfachste Weg. Die Aktualisierung mit dieser Methode ist einfach, allerdings musst du bei dieser Methode eine Menge unnötiger Dinge herunterladen, die du nicht brauchst. Es gibt einige Themes, vor allem die kostenpflichtigen, die kein GitHub-Repository haben, aus dem du sie herunterladen kannst. Solche Themes werden normalerweise als komprimiertes Archiv angeboten. In diesem Fall musst du das Archiv manuell entpacken und das Theme manuell aktualisieren. Die dritte Methode besteht darin, das Thema als Git-Submodul herunterzuladen. Dazu musst du dein Hugo-Verzeichnis als Git-Repository einrichten. Diese Methode wird empfohlen und ist nützlich, wenn du deine Website auf GitHub, Netlify oder einem anderen Hosting-Dienst bereitstellen willst. Wenn du deine Hugo-Site auf GitHub bereitstellst, werden auch automatische Backups ohne zusätzlichen Aufwand erstellt.
Wir werden alle drei Methoden behandeln. Es gibt noch eine andere Methode, ein Hugo-Theme mit Hugo Go-Modulen zu installieren. Diese Methode funktioniert nur, wenn das Thema als Hugo-Modul verfügbar ist. Wir werden sie jedoch nicht behandeln, da sie den Rahmen dieses Artikels sprengen würde.
Methode 1 – Klonen eines Hugo-Themas
Dies ist die am häufigsten verwendete Methode, um ein Hugo-Theme zu installieren. Für unser Tutorial werden wir das Paper-Theme installieren. Wechsle in das Hugo-Verzeichnis.
$ cd /var/www/html/hugo/howtoforge
Führe den folgenden Befehl aus, um das GitHub-Repository des Themas zu klonen. Das --depth=1 Flag greift nur auf die letzte Übertragung zu.
$ sudo git clone https://github.com/nanxiaobei/hugo-paper themes/Paper --depth=1
Um das mit dieser Methode heruntergeladene Theme zu aktualisieren, führe die folgenden Befehle aus.
$ cd ~/hugo/howtoforge/themes/Paper $ sudo git pull
Methode 2 – Installation des Themes aus einem komprimierten Archiv
Dies ist die einfachste Methode von allen. Schnapp dir das Archiv mit der Themadatei. Das Paper-Theme hat keinen Versionsbereich, du kannst also keine bestimmte Version herunterladen. Deshalb laden wir das GitHub Master-Archiv herunter. Du kannst den Link von der GitHub-Repository-Seite herunterladen.
$ cd ~ $ wget https://github.com/nanxiaobei/hugo-paper/archive/refs/heads/main.zip
Entpacke das Archiv in das themes-Verzeichnis. Das -q Flag unterdrückt die Ausgabe und das -d Flag gibt das Ausgabeverzeichnis an.
$ sudo unzip -q main.zip -d /var/www/html/hugo/howtoforge/themes/
Um das Theme zu aktualisieren, musst du das neueste Archiv herunterladen und es erneut entpacken. Stelle sicher, dass du ein Backup aller Dateien machst, die du geändert hast.
Die beiden unteren Methoden funktionieren nur, wenn deine Hugo-Website als Git-Projekt gehostet wird. Ansonsten brauchst du die folgenden Methoden nicht anzuwenden.
Methode 3 – Installation des Themas als Git-Submodul
Wechsle in den Hugo-Ordner.
$ cd /var/www/html/hugo/howtoforge
Initialisiere den Hugo-Ordner als Git-Repository. Dies ist ein wichtiger Schritt. Damit kannst du deine Hugo-Site auf GitHub pushen, um sie später mit Netlify, AWS, Vercel usw. zu hosten.
$ sudo git init
Führe den folgenden Befehl aus, um das Thema als Git-Submodul hinzuzufügen.
$ sudo git submodule add https://github.com/nanxiaobei/hugo-paper themes/paper
Um ein als Submodul hinzugefügtes Thema zu aktualisieren, führe den folgenden Befehl im Hugo-Ordner aus.
$ sudo git submodule update --remote --merge
Hugo konfigurieren
Wenn du das Thema mit einer Methode deiner Wahl installiert hast, öffne die Datei hugo.toml im Hauptverzeichnis von Hugo. Ab Hugo v0.110.0 heißt die Standardkonfigurationsdatei hugo.toml. Wenn du eine ältere Version von Hugo verwendest, findest du die Datei config.toml in deinem Hugo-Verzeichnis.
$ sudo nano hugo.toml
Füge die folgende Zeile in die Datei ein. Der Wert sollte mit dem Verzeichnis des Themas übereinstimmen. Für das Papierthema wäre das das Verzeichnis hugo-paper-theme, wenn du die Archivinstallation benutzt hast, oder Paper, wenn du den Git-Klon oder die Submodulmethode oben benutzt hast.
theme = 'hugo-paper-main'
Ändere außerdem den Wert der Variable baseURL in den Domainnamen deiner Website. Und ändere die title deiner Website.
Deine Konfigurationsdatei sollte wie die folgende aussehen.
baseURL = 'https://hugo.example.com/' languageCode = 'en-us' title = 'Howtoforge Hugo Demo' theme = 'hugo-paper-main'
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Schritt 7 – Beiträge und Seiten erstellen
Um einen neuen Beitrag zu erstellen, gibst du den folgenden Befehl ein.
$ sudo hugo new post/first-post.md
Dadurch wird eine neue Markdown-Datei first-post.md mit dem Titel First Post im Ordner content/post erstellt. Öffne die Datei in deinem Lieblingseditor und editiere die Details und schreibe etwas für deinen ersten Beitrag.
+++ title = 'First Post' date = 2023-10-30T03:32:38Z draft = true +++ ## Introduction This is **bold** text, and this is *emphasized* text. Visit the [Howtoforge](https://howtoforge.com) website!
Entferne die draft = true, sobald du den Beitrag fertig geschrieben hast. Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Um eine neue Seite zu erstellen, gibst du den folgenden Befehl ein.
$ sudo hugo new about.md
Dadurch wird eine neue Seite mit dem Titel About im Ordner content erstellt. Öffne sie und bearbeite sie auf die gleiche Weise wie den Beitrag.
Thema konfigurieren
Vor der Veröffentlichung müssen wir noch einige Änderungen am Theme vornehmen, damit die Menüleiste angezeigt wird. Diese Änderungen werden in der Konfigurationsdatei von Hugo vorgenommen und nicht in der Konfiguration des Themes.
Wechsle in das Hugo-Verzeichnis.
$ cd /var/www/html/hugo/howtoforge
Öffne die Datei hugo.toml zum Bearbeiten.
$ sudo nano hugo.toml
Füge den folgenden Code am Ende der Datei ein.
author = "Navjot Singh"
copyright = "Copyright © 2023, Navjot Singh; all rights reserved."
paginate = 3
enableInlineShortcodes = true
# needed to render raw HTML (e.g. <sub>, <sup>, <kbd>, <mark>)
[markup]
[markup.goldmark]
[markup.goldmark.renderer]
unsafe = true
[menu]
[[menu.main]]
identifier = "about"
name = "About"
url = "/about/"
weight = 10
[taxonomies]
category = "categories"
tag = "tags"
series = "series"
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Dies sind einige grundlegende Einstellungen, um die Website funktionsfähig zu machen. Hier haben wir die Seite so konfiguriert, dass 3 Beiträge pro Seite angezeigt werden, die Info-Seite als Menüpunkt erscheint und Kategorien, Tags und Beitragsserien eingerichtet werden. Außerdem haben wir die Inline-Shortcodes von Hugo aktiviert und das Rendering von Goldmark Markdown in Roh-HTML aktiviert. Du kannst diese Option deaktivieren, wenn du kein Roh-HTML in deine Beiträge einbetten möchtest.
Schritt 8 – Hugo-Site veröffentlichen
Um die Seite zu erstellen und zu veröffentlichen, führst du einfach den folgenden Befehl aus.
$ sudo hugo
Du wirst eine ähnliche Ausgabe erhalten.
Start building sites …
hugo v0.119.0-b84644c008e0dc2c4b67bd69cccf87a41a03937e+extended linux/amd64 BuildDate=2023-09-24T15:20:17Z VendorInfo=gohugoio
| EN
-------------------+-----
Pages | 7
Paginator pages | 0
Non-page files | 0
Static files | 11
Processed images | 0
Aliases | 3
Sitemaps | 1
Cleaned | 0
Total in 46 ms
Damit wird die statische Hugo-Website im Ordner public erstellt und veröffentlicht. Dies sind die Dateien, die wir in der Nginx-Konfiguration angeben müssen, damit die Seite funktioniert. Führe den Befehl nach jeder Änderung erneut aus und deine Website wird im Handumdrehen aktualisiert.
Schritt 9 – SSL installieren
Bevor wir fortfahren, müssen wir das Tool Certbot installieren und ein SSL-Zertifikat für unsere Domain einrichten.
Um Certbot zu installieren, verwenden wir den Snapd-Paketinstaller. Snapd enthält immer die neueste stabile Version von Certbot und du solltest diese verwenden.
Das Snapd-Tool benötigt das Epel-Repository, um zu funktionieren.
$ sudo dnf install epel-release -y
Wir werden Snapd verwenden, um Certbot zu installieren. Installiere Snapd.
$ sudo dnf install snapd -y
Aktiviere und starte den Snap-Dienst.
$ sudo systemctl enable snapd.socket --now
Erstelle die notwendigen Links, damit Snapd funktioniert.
$ sudo ln -s /var/lib/snapd/snap /snap $ echo 'export PATH=$PATH:/var/lib/snapd/snap/bin' | sudo tee -a /etc/profile.d/snapd.sh
Stelle sicher, dass deine Snapd-Version auf dem neuesten Stand ist. Warte ein paar Sekunden, bevor du die folgenden Befehle ausführst.
$ sudo snap install core $ sudo snap refresh core
Installiere Certbot.
$ sudo snap install --classic certbot
Stelle mit dem folgenden Befehl sicher, dass der Certbot-Befehl ausgeführt werden kann, indem du einen symbolischen Link auf das Verzeichnis /usr/bin erstellst.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Überprüfe die Installation.
$ certbot --version certbot 2.7.3
Erstelle ein SSL-Zertifikat.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d hugo.example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/hugo.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-Erneuerungsplanerdienst.
$ 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 Wed 2023-10-29 10:00:17 UTC 57min left Wed 2023-10-18 08:49:39 UTC 12min ago dnf-makecache.timer dnf-makecache.service Wed 2023-10-29 12:18:00 UTC 3h 15min left - - snap.certbot.renew.timer snap.certbot.renew.service Thu 2023-10-30 00:00:00 UTC 14h left Wed 2023-10-18 08:10:08 UTC 52min ago logrotate.timer logrotate.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 10 – Nginx konfigurieren
Erstelle und öffne die Datei /etc/nginx/conf.d/hugo.conf zum Bearbeiten.
$ sudo nano /etc/nginx/conf.d/hugo.conf
Füge den folgenden Code in die Datei hugo.conf ein. Ersetze alle Instanzen von hugo.example.com durch deine Domain.
## enforce HTTPS
server {
listen 80;
listen [::]:80;
server_name hugo.example.com;
return 301 https://$server_name$request_uri;
}
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
server_name hugo.example.com;
root /home/navjot/hugo/howtoforge/public;
index index.html
access_log /var/log/nginx/hugo.access.log;
error_log /var/log/nginx/hugo.error.log;
client_max_body_size 20m;
gzip on;
http2_push_preload on; # Enable HTTP/2 Server Push
ssl_certificate /etc/letsencrypt/live/hugo.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/hugo.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/hugo.example.com/chain.pem;
ssl_session_timeout 1d;
# Enable TLS versions (TLSv1.3 is required upcoming HTTP/3 QUIC).
ssl_protocols TLSv1.2 TLSv1.3;
# Enable TLSv1.3's 0-RTT. Use $ssl_early_data when reverse proxying to
# prevent replay attacks.
#
# @see: https://nginx.org/en/docs/http/ngx_http_ssl_module.html#ssl_early_data
ssl_early_data on;
ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384';
ssl_prefer_server_ciphers on;
ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
ssl_session_cache shared:SSL:50m;
ssl_session_tickets off;
# OCSP Stapling ---
# fetch OCSP records from URL in ssl_certificate and cache them
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
add_header X-Early-Data $tls1_3_early_data;
location / {
try_files $uri $uri/ =404;
}
# Media
location ~* \.(?:jpg|jpeg|gif|png|ico|cur|gz|svg|mp4|ogg|ogv|webm|htc)$ {
expires 30d;
}
# CSS and Js
location ~* \.(css|js)$ {
expires 7d;
}
}
# This block is useful for debugging TLS v1.3. Please feel free to remove this
# and use the `$ssl_early_data` variable exposed by NGINX directly should you
# wish to do so.
map $ssl_early_data $tls1_3_early_data {
"~." $ssl_early_data;
default "";
}
Die obige Konfiguration leitet alle HTTP-Anfragen auf HTTPS um und dient als Proxy für den Hugo-Dienst, um ihn über deine Domain zu bedienen.
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Ö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 deine Nginx-Konfiguration.
$ sudo nginx -t
Wenn du keine Fehler siehst, bist du startklar. Lade den Nginx-Server neu.
$ sudo systemctl reload nginx
Schritt 11 – SELinux konfigurieren
Ändere den Dateisicherheitskontext für OpenEMR.
$ sudo semanage fcontext -a -t httpd_sys_rw_content_t "/var/www/html/hugo/howtoforge/public(/.*)?"
Wende die Richtlinie an.
$ sudo restorecon -Rv /var/www/html/hugo/howtoforge/public/
Erlaube Nginx, sich mit dem Netzwerk zu verbinden.
$ sudo setsebool -P httpd_can_network_connect 1
Schritt 12 – Ausführen der Website
Jetzt kannst du deine Installation überprüfen, indem du https://hugo.example.com in deinem Webbrowser öffnest. Du erhältst die folgende Seite, die eine erfolgreiche Installation anzeigt.
Schritt 13 – Hugo aktualisieren
Die Aktualisierung von Hugo ist ziemlich einfach. Lade die neueste Version von Hugos GitHub-Seite herunter.
$ cd /var/www/html/hugo $ sudo wget https://github.com/gohugoio/hugo/releases/download/v0.119.0/hugo_extended_0.119.0_linux-amd64.tar.gz
Entpacke das Archiv.
$ sudo tar -xzf hugo_extended_0.119.0_linux-amd64.tar.gz
Ersetze die Hugo-Binärdatei durch die neueste Version. Das -f Flag überschreibt die Binärdatei ohne Rückfrage. Du kannst stattdessen das -i Flag verwenden, wenn du eine Aufforderung zum Überschreiben haben möchtest.
$ sudo mv -f hugo /usr/bin/hugo
Das war’s schon. Die Aktualisierung von Hugo ist so einfach wie das Ersetzen der Binärdatei.
Schritt 14 – Sichern und Wiederherstellen von Hugo
Um ein Backup zu machen, erstellst du ein Archiv des gesamten Hugo-Ordners.
$ cd /var/www/html/hugo $ sudo tar -czvf howtoforge.tar.gz howtoforge/
Um ihn auf einem neuen Server wiederherzustellen, entpackst du das Archiv und installierst die Binärdatei – und schon bist du startklar.
$ cd /var/www/html/hugo $ sudo tar -xzf howtoforge.tar.gz
Fazit
Damit ist unsere Anleitung zur Einrichtung des statischen Website-Generators Hugo auf deinem Rocky Linux 9 Server mit Nginx abgeschlossen. Wenn du Fragen oder Anregungen hast, schreibe sie in die Kommentare unten.