Hugo Nginx · 18 min read · Oct 19, 2025
Cómo instalar el generador de sitios Hugo con Nginx en Rocky Linux 9
Un sitio estático se construye con páginas de contenido estático o código HTML, JavaScript o CSS simple. El contenido no se genera dinámicamente y no implica ningún procesamiento en la base de datos o del lado del servidor. Tales sitios son increíblemente rápidos e inmunes a exploits que dependen de código dinámico o SQL.
Hugo es un generador de sitios estáticos de código abierto escrito en Go. Genera contenido convirtiendo publicaciones escritas en lenguaje markdown a HTML. Hugo también incluye un servidor integrado para alojar los sitios que genera. También puedes alojar un sitio web de Hugo en Amazon S3, páginas de GitHub, Google Cloud, Netlify, Vercel, etc.
En este tutorial, exploraremos cómo instalar Hugo para crear un sitio web estático en un servidor impulsado por Rocky Linux 9. Usaremos el servidor Nginx para alojar el sitio y el certificado SSL de Let’s Encrypt para asegurar nuestra instalación.
Requisitos previos
- Un servidor que ejecute Rocky Linux 9.
- Un usuario no root con privilegios sudo.
- Un nombre de dominio completamente calificado (FQDN) apuntando a tu servidor. Para nuestros propósitos, usaremos
hugo.example.comcomo el nombre de dominio. - Asegúrate de que todo esté actualizado.
$ sudo dnf update - Instala paquetes de utilidad básicos. Algunos de ellos pueden ya estar instalados.
$ sudo dnf install wget curl nano unzip yum-utils tree -y
Paso 1 - Configurar el Firewall
El primer paso es configurar el firewall. Rocky Linux utiliza Firewalld Firewall. Verifica el estado del firewall.
$ sudo firewall-cmd --state
running
El firewall trabaja con diferentes zonas, y la zona pública es la predeterminada que utilizaremos. Lista todos los servicios y puertos activos en el firewall.
$ sudo firewall-cmd --permanent --list-services
Debería mostrar la siguiente salida.
cockpit dhcpv6-client ssh
Wiki.js necesita los puertos HTTP y HTTPS para funcionar. Ábrelos.
$ sudo firewall-cmd --add-service=http --permanent
$ sudo firewall-cmd --add-service=https --permanent
Recarga el firewall para aplicar los cambios.
$ sudo firewall-cmd --reload
Paso 2 - Instalar Nginx
Rocky Linux 9 incluye una versión más antigua de Nginx. Necesitas descargar el repositorio oficial de Nginx para instalar la última versión.
Crea y abre el archivo /etc/yum.repos.d/nginx.repo para crear el repositorio oficial de Nginx.
$ sudo nano /etc/yum.repos.d/nginx.repo
Pega el siguiente código en él.
[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
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Instala el servidor Nginx.
$ sudo dnf install nginx -y
Verifica la instalación.
$ nginx -v
nginx version: nginx/1.24.0
Habilita e inicia el servidor Nginx.
$ sudo systemctl enable nginx --now
Verifica el estado del servidor.
$ sudo systemctl status nginx
? nginx.service - nginx - servidor web de alto rendimiento
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...
Paso 3 - Instalar Git
Hugo necesita Git para funcionar. Ejecuta el siguiente comando para instalar Git
$ sudo dnf install git -y
Verifica la instalación de Git.
$ git --version
git version 2.39.3
Paso 4 - Instalar Hugo
Dado que Hugo está construido usando el lenguaje Go, instalarlo es bastante fácil ya que no requiere ninguna dependencia y puede ejecutarse de forma independiente.
Descarga Hugo. Para nuestro tutorial, instalaremos la versión extendida de Hugo. La versión extendida puede codificar imágenes en el formato Webp al procesar imágenes. Esto es útil si deseas que Hugo convierta imágenes por ti sobre la marcha y mantenga sus tamaños bajos. La versión extendida también incluye un compilador SASS que puede ser útil en ciertos casos si lo necesitas.
Crea un directorio para Hugo.
$ sudo mkdir /var/www/html/hugo -p
Cambia al directorio recién creado.
$ cd /var/www/html/hugo
Descarga Hugo desde la página de lanzamientos de GitHub. En el momento de escribir este tutorial, v0.119.0 es la última versión que es lo que descargaremos.
$ sudo wget https://github.com/gohugoio/hugo/releases/download/v0.119.0/hugo_extended_0.119.0_linux-amd64.tar.gz
Extrae los archivos del archivo.
$ sudo tar -xzf hugo_extended_0.119.0_linux-amd64.tar.gz
Verás los siguientes tres archivos en tu directorio.
$ ls
hugo hugo_extended_0.119.0_linux-amd64.tar.gz LICENSE README.md
Mueve el binario hugo al directorio /usr/bin.
$ sudo mv hugo /usr/bin/hugo
El archivo ya tiene permisos de ejecución establecidos, por lo que no necesitas configurarlos.
Confirma la instalación.
$ hugo version
hugo v0.119.0-b84644c008e0dc2c4b67bd69cccf87a41a03937e+extended linux/amd64 BuildDate=2023-09-24T15:20:17Z VendorInfo=gohugoio
También puedes verificar todas las opciones disponibles para usar utilizando la bandera --help.
$ hugo --help
Obtendrás la siguiente salida.
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.
Elimina todos los archivos restantes en la carpeta ya que ya no son necesarios.
$ sudo rm -rf *.*
Paso 5 - Crear un nuevo sitio Hugo
Emite el siguiente comando para crear un nuevo sitio web Hugo.
$ sudo hugo new site howtoforge
Obtendrás la siguiente salida.
¡Felicidades! Tu nuevo sitio Hugo fue creado en /home/navjot/hugo/howtoforge.
Solo unos pocos pasos más...
1. Cambia el directorio actual a /home/navjot/hugo/howtoforge.
2. Crea o instala un tema:
- Crea un nuevo tema con el comando "hugo new theme "
- Instala un tema de https://themes.gohugo.io/
3. Edita hugo.toml, configurando la propiedad "theme" al nombre del tema.
4. Crea nuevo contenido con el comando "hugo new content /.".
5. Inicia el servidor web integrado con el comando "hugo server --buildDrafts".
Consulta la documentación en https://gohugo.io/.
Ejecuta el comando tree para verificar la estructura del sitio.
$ tree howtoforge/
Obtendrás la siguiente salida.
howtoforge/
??? archetypes
? ??? default.md
??? assets
??? content
??? data
??? hugo.toml
??? i18n
??? layouts
??? static
??? themes
8 directories, 2 files
Cambia al directorio de Hugo.
$ cd howtoforge
Paso 6 - Instalar el tema de Hugo
El siguiente paso es instalar un tema de Hugo. Hay dos formas de hacerlo y ambas requieren Git. El primer método es simple y directo e implica clonar el repositorio de GitHub del tema. Esto es útil en la mayoría de los casos y la forma más fácil de hacerlo. Actualizar a través de este método es fácil, aunque este método implica descargar muchas cosas innecesarias que no necesitas. Hay algunos temas, especialmente los de pago, que no tienen un repositorio de GitHub desde donde puedas obtenerlos. Tales temas suelen ofrecerse como un archivo comprimido. En ese caso, necesitas extraer el archivo manualmente y mantener el tema actualizado manualmente. El tercer método implica obtener el tema como un submódulo de Git. Esto requiere que inicialices tu directorio de Hugo como un repositorio de Git. Este es el método recomendado y es útil en caso de que desees desplegar tu sitio en GitHub, Netlify o cualquier otro servicio de alojamiento. Subir tu sitio Hugo a GitHub asegura copias de seguridad automáticas también sin ningún esfuerzo adicional.
Cubriré los tres métodos. Hay otro método de instalación de un tema de Hugo utilizando módulos de Hugo Go. Este método solo funciona si el tema está disponible como un módulo de Hugo. Sin embargo, no lo cubriremos ya que está fuera del alcance de este artículo.
Método 1 - Clonando un tema de Hugo
Este es el método más comúnmente utilizado para instalar un tema de Hugo. Para nuestro tutorial, instalaremos el tema Paper. Cambia al directorio de Hugo.
$ cd /var/www/html/hugo/howtoforge
Ejecuta el siguiente comando para clonar el repositorio de GitHub del tema. La bandera --depth=1 solo obtiene el último commit.
$ sudo git clone https://github.com/nanxiaobei/hugo-paper themes/Paper --depth=1
Para actualizar el tema descargado a través de este método, ejecuta los siguientes comandos.
$ cd ~/hugo/howtoforge/themes/Paper
$ sudo git pull
Método 2 - Instalando el tema desde un archivo comprimido
Este es el método más fácil de todos. Obtén el archivo comprimido del tema. El tema Paper no tiene una sección de lanzamientos, por lo que no puedes descargar una versión particular. Por lo tanto, descargaremos el archivo comprimido de la rama principal de GitHub. Puedes obtener el enlace desde su página de repositorio de GitHub.
$ cd ~
$ wget https://github.com/nanxiaobei/hugo-paper/archive/refs/heads/main.zip
Extrae el archivo comprimido en el directorio de temas. La bandera -q suprime la salida y la bandera -d especifica el directorio de salida.
$ sudo unzip -q main.zip -d /var/www/html/hugo/howtoforge/themes/
Para actualizar el tema, necesitas descargar el último archivo comprimido y extraerlo nuevamente. Asegúrate de hacer una copia de seguridad de todos los archivos que has cambiado.
Los dos métodos inferiores solo funcionan si tu sitio Hugo está alojado como un proyecto de Git. De lo contrario, no necesitas usar los siguientes métodos.
Método 3 - Instalando el tema como un submódulo de Git
Cambia al directorio de Hugo.
$ cd /var/www/html/hugo/howtoforge
Inicializa la carpeta de Hugo como un repositorio de Git. Este es un paso importante. Esto te permite subir tu sitio Hugo a GitHub para usarlo más tarde para alojarlo utilizando Netlify, AWS, Vercel, etc.
$ sudo git init
Ejecuta el siguiente comando para agregar el tema como un submódulo de Git.
$ sudo git submodule add https://github.com/nanxiaobei/hugo-paper themes/paper
Para actualizar un tema agregado como submódulo, ejecuta el siguiente comando desde la carpeta de Hugo.
$ sudo git submodule update --remote --merge
Configurar Hugo
Una vez que hayas instalado el tema utilizando un método de tu elección, abre el archivo hugo.toml en el directorio raíz de tu Hugo. A partir de Hugo v0.110.0, el archivo de configuración predeterminado se llama hugo.toml. Si estás usando una versión anterior de Hugo, encontrarás el archivo config.toml en tu directorio de Hugo.
$ sudo nano hugo.toml
Agrega la siguiente línea al archivo. El valor debe coincidir con el directorio del tema. Para el tema Paper, ese sería el directorio hugo-paper-theme si usaste la instalación del archivo comprimido o Paper si usaste el método de clonación de Git o submódulo mencionado anteriormente.
theme = 'hugo-paper-main'
Además, cambia el valor de la variable baseURL al nombre de dominio de tu sitio. Y cambia el title de tu sitio web.
Tu archivo de configuración debería verse como el siguiente.
baseURL = 'https://hugo.example.com/'
languageCode = 'en-us'
title = 'Demostración de Hugo en Howtoforge'
theme = 'hugo-paper-main'
Una vez terminado, guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Paso 7 - Crear publicaciones y páginas
Para crear una nueva publicación, emite el siguiente comando.
$ sudo hugo new post/first-post.md
Esto creará un nuevo archivo markdown first-post.md con el título Primera Publicación en la carpeta content/post. Abre el archivo en tu editor favorito y edita los detalles y escribe algo para tu primera publicación.
+++
title = 'Primera Publicación'
date = 2023-10-30T03:32:38Z
draft = true
+++
## Introducción
Este es un texto en negrita, y este es un texto *enfatizado*.
Visita el sitio web de [Howtoforge](https://www.howtoforge.com)!
Elimina draft = true una vez que hayas terminado de escribir la publicación. Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Para crear una nueva página, emite el siguiente comando.
$ sudo hugo new about.md
Esto creará una nueva página titulada Acerca de en la carpeta content. Ábrela y edítala de la misma manera que la publicación.
Configurar el tema
Antes de publicar, necesitamos hacer algunos cambios en el tema para mostrar la barra de menú. Estos cambios se realizarán en el archivo de configuración de Hugo y no en la configuración del tema.
Cambia al directorio de Hugo.
$ cd /var/www/html/hugo/howtoforge
Abre el archivo hugo.toml para editarlo.
$ sudo nano hugo.toml
Pega el siguiente código al final.
author = "Navjot Singh"
copyright = "Copyright © 2023, Navjot Singh; todos los derechos reservados."
paginate = 3
enableInlineShortcodes = true
# necesario para renderizar HTML sin procesar (por ejemplo, , , , )
[markup]
[markup.goldmark]
[markup.goldmark.renderer]
unsafe = true
[menu]
[[menu.main]]
identifier = "about"
name = "Acerca de"
url = "/about/"
weight = 10
[taxonomies]
category = "categorías"
tag = "etiquetas"
series = "series"
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Estas son algunas configuraciones básicas para hacer que el sitio funcione. Aquí hemos configurado el sitio para mostrar 3 publicaciones por página, mostrar la página Acerca de como un elemento de menú y configurar categorías, etiquetas y series de publicaciones. También hemos habilitado los shortcodes en línea de Hugo y habilitado HTML sin procesar para el renderizador Markdown Goldmark. Puedes deshabilitarlo si no deseas incrustar HTML sin procesar en tus publicaciones.
Paso 8 - Publicar el sitio Hugo
Para construir y publicar el sitio, solo ejecuta el siguiente comando.
$ sudo hugo
Obtendrás una salida similar.
Comenzando a construir sitios …
hugo v0.119.0-b84644c008e0dc2c4b67bd69cccf87a41a03937e+extended linux/amd64 BuildDate=2023-09-24T15:20:17Z VendorInfo=gohugoio
| EN
-------------------+-----
Páginas | 7
Páginas de paginación | 0
Archivos no página | 0
Archivos estáticos | 11
Imágenes procesadas | 0
Alias | 3
Sitemaps | 1
Limpiados | 0
Total en 46 ms
Esto crea y publica el sitio web estático de Hugo en la carpeta public. Estos son los archivos que necesitamos especificar en la configuración de Nginx para que el sitio funcione. Ejecuta el comando nuevamente después de realizar cualquier cambio y tu sitio web se actualizará en poco tiempo.
Paso 9 - Instalar SSL
Antes de continuar, necesitamos instalar la herramienta Certbot e instalar un certificado SSL para nuestro dominio.
Para instalar Certbot, utilizaremos el instalador de paquetes Snapd. Snapd siempre lleva la última versión estable de Certbot y deberías usar eso.
La herramienta Snapd requiere el repositorio Epel para funcionar.
$ sudo dnf install epel-release -y
Usaremos Snapd para instalar Certbot. Instala Snapd.
$ sudo dnf install snapd -y
Habilita e inicia el servicio Snap.
$ sudo systemctl enable snapd.socket --now
Crea los enlaces necesarios para que Snapd funcione.
$ 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
Asegúrate de que tu versión de snapd esté actualizada. Espera un par de segundos antes de emitir los siguientes comandos.
$ sudo snap install core
$ sudo snap refresh core
Instala Certbot.
$ sudo snap install --classic certbot
Usa el siguiente comando para asegurarte de que el comando Certbot se pueda ejecutar creando un enlace simbólico al directorio /usr/bin.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Verifica la instalación.
$ certbot --version
certbot 2.7.3
Genera un certificado SSL.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d hugo.example.com
El comando anterior descargará un certificado en el directorio /etc/letsencrypt/live/hugo.example.com en tu servidor.
Genera un certificado de grupo Diffie-Hellman.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Verifica el servicio programador de renovación de Certbot.
$ sudo systemctl list-timers
Encontrarás snap.certbot.renew.service como uno de los servicios programados para ejecutarse.
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
Haz una prueba del proceso para verificar si la renovación de SSL está funcionando bien.
$ sudo certbot renew --dry-run
Si no ves errores, estás listo. Tu certificado se renovará automáticamente.
Paso 10 - Configurar Nginx
Crea y abre el archivo /etc/nginx/conf.d/hugo.conf para editarlo.
$ sudo nano /etc/nginx/conf.d/hugo.conf
Pega el siguiente código en el archivo hugo.conf. Reemplaza todas las instancias de hugo.example.com con tu dominio.
## forzar 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; # Habilitar 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;
# Habilitar versiones TLS (TLSv1.3 es requerido para el próximo HTTP/3 QUIC).
ssl_protocols TLSv1.2 TLSv1.3;
# Habilitar 0-RTT de TLSv1.3. Usa $ssl_early_data cuando se haga proxy inverso para
# prevenir ataques de repetición.
#
# @ver: 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 ---
# obtener registros OCSP de la URL en ssl_certificate y almacenarlos en caché
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;
}
# Medios
location ~* \\.jpg|jpeg|gif|png|ico|cur|gz|svg|mp4|ogg|ogv|webm|htc$ {
expires 30d;
}
# CSS y Js
location ~* \\.css|js$ {
expires 7d;
}
}
# Este bloque es útil para depurar TLS v1.3. Siéntete libre de eliminar esto
# y usar la variable $ssl_early_data expuesta por NGINX directamente si así lo deseas.
map $ssl_early_data $tls1_3_early_data {
"~." $ssl_early_data;
default "";
}
La configuración anterior redirigirá todas las solicitudes HTTP a HTTPS y servirá como un proxy para que el servicio Hugo lo sirva a través de tu dominio.
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Abre el archivo /etc/nginx/nginx.conf para editarlo.
$ sudo nano /etc/nginx/nginx.conf
Agrega la siguiente línea antes de la línea include /etc/nginx/conf.d/*.conf;.
server_names_hash_bucket_size 64;
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Verifica tu configuración de Nginx.
$ sudo nginx -t
Si no ves errores, significa que estás listo para continuar. Recarga el servidor Nginx.
$ sudo systemctl reload nginx
Paso 11 - Configurar SELinux
Cambia el contexto de seguridad del archivo para OpenEMR.
$ sudo semanage fcontext -a -t httpd_sys_rw_content_t "/var/www/html/hugo/howtoforge/public(/.*)?"
Aplica la política.
$ sudo restorecon -Rv /var/www/html/hugo/howtoforge/public/
Permite que Nginx se conecte a la red.
$ sudo setsebool -P httpd_can_network_connect 1
Paso 12 - Ejecutar el sitio
Ahora, puedes verificar tu instalación abriendo https://hugo.example.com en tu navegador web. Obtendrás la siguiente página que indica una instalación exitosa.
Paso 13 - Actualizar Hugo
Actualizar Hugo es bastante simple. Descarga la última versión desde la página de GitHub de Hugo.
$ 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
Extrae el archivo comprimido.
$ sudo tar -xzf hugo_extended_0.119.0_linux-amd64.tar.gz
Y reemplaza el binario de Hugo con la última versión. La bandera -f sobrescribe el binario sin preguntar. Puedes usar la bandera -i en su lugar si deseas que te pregunte antes de sobrescribir.
$ sudo mv -f hugo /usr/bin/hugo
Eso es todo. Actualizar Hugo es tan simple como reemplazar el binario.
Paso 14 - Respaldo y restauración de Hugo
Para hacer una copia de seguridad, crea un archivo comprimido de toda la carpeta de Hugo.
$ cd /var/www/html/hugo
$ sudo tar -czvf howtoforge.tar.gz howtoforge/
Para restaurarlo en un nuevo servidor, extrae el archivo comprimido e instala el binario y estarás listo para continuar.
$ cd /var/www/html/hugo
$ sudo tar -xzf howtoforge.tar.gz
Conclusión
Esto concluye nuestro tutorial sobre cómo configurar el generador de sitios estáticos Hugo en tu servidor Rocky Linux 9 utilizando Nginx. Si tienes alguna pregunta o comentario, compártelos en los comentarios a continuación.
Recibe nuevas publicaciones en tu bandeja de entrada.
No spam. Cancela la suscripción en cualquier momento.