Instalación Craft CMS · 23 min read · Sep 11, 2025
Cómo instalar Craft CMS en Rocky Linux 9
Craft CMS es un sistema de gestión de contenido de código abierto para crear sitios web. Es un CMS seguro y escalable con un extenso ecosistema de plugins y plugins de alta calidad, tanto gratuitos como de pago. Tiene un panel de control intuitivo y fácil de usar para la creación de contenido y tareas administrativas. Está construido sobre el marco Yii PHP. El motor de plantillas Twig potencia su sistema de plantillas. Puede trabajar con bases de datos MySQL y PostgreSQL para almacenamiento y utiliza la base de datos Redis para almacenamiento en caché y de sesiones.
En este tutorial, aprenderás cómo instalar Craft CMS en un servidor Debian 12. También aprenderás cómo habilitar Redis para trabajar con él y cómo hacer copias de seguridad y restaurar un sitio creado con Craft CMS.
Requisitos previos
- Un servidor que ejecute Rocky Linux 9 con un mínimo de 1 GB de RAM.
- Un usuario no root con privilegios sudo.
- Un Nombre de Dominio Totalmente Calificado (FQDN) como
craftcms.example.comapuntando a tu servidor. - Una cuenta SMTP con un servicio de correo electrónico como Amazon SES o Mailgun.
- Todo está actualizado.
$ sudo dnf update - Se requieren algunos paquetes esenciales para que el tutorial y Craft CMS funcionen. Algunos de estos ya estarán en tu servidor.
$ sudo dnf install wget curl nano unzip yum-utils policycoreutils-python-utils -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
Permite los puertos HTTP y HTTPS.
$ sudo firewall-cmd --permanent --add-service=http
$ sudo firewall-cmd --permanent --add-service=https
Vuelve a verificar el estado del firewall.
$ sudo firewall-cmd --permanent --list-services
Deberías ver una salida similar.
cockpit dhcpv6-client http https ssh
Recarga el firewall para habilitar los cambios.
$ sudo firewall-cmd --reload
Paso 2 - Instalar Nginx
Rocky Linux 9 viene con una versión más antigua de Nginx. Necesitas usar el repositorio oficial de Nginx para instalar la última versión.
Crea y abre el archivo /etc/yum.repos.d/nginx.repo para editar.
$ 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
Una vez que hayas terminado, guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Instala Nginx.
$ sudo dnf install nginx -y
Verifica la instalación.
$ nginx -v
nginx version: nginx/1.24.0
Habilita e inicia el servicio del servidor Nginx.
$ sudo systemctl enable nginx --now
Verifica el estado del servicio.
$ 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-12-04 14:01:19 UTC; 3s ago
Docs: http://nginx.org/en/docs/
Process: 59396 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
Main PID: 59397 (nginx)
Tasks: 2 (limit: 10866)
Memory: 1.9M
CPU: 10ms
CGroup: /system.slice/nginx.service
??59397 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
??59398 "nginx: worker process"
Paso 3 - Instalar PHP y extensiones
Rocky Linux 9 viene con PHP 8.1 por defecto. Para mantener siempre la última versión de PHP o si deseas instalar múltiples versiones de PHP, necesitamos usar el repositorio REMI.
El primer paso es obtener el repositorio Epel.
$ sudo dnf install epel-release -y
A continuación, instala el repositorio Remi.
$ sudo dnf install https://rpms.remirepo.net/enterprise/remi-release-9.rpm
Verifica los flujos de PHP disponibles.
$ dnf module list php -y
Name Stream Profiles Summary
php 8.1 common [d], devel, minimal PHP scripting language
Remi's Modular repository for Enterprise Linux 9 - x86_64
Name Stream Profiles Summary
php remi-7.4 common [d], devel, minimal PHP scripting language
php remi-8.0 common [d], devel, minimal PHP scripting language
php remi-8.1 common [d], devel, minimal PHP scripting language
php remi-8.2 common [d], devel, minimal PHP scripting language
php remi-8.3 common [d], devel, minimal PHP scripting language
Hint: [d]efault, [e]nabled, [x]disabled, [i]nstalled
La versión predeterminada es 8.1. En el momento de escribir este tutorial, Craft CMS es compatible con PHP 8.2. Por lo tanto, habilita el repositorio PHP 8.2 de Remi.
$ sudo dnf module reset php -y
$ sudo dnf module enable php:remi-8.2
Instala PHP y sus extensiones requeridas por Craft CMS.
$ sudo dnf install php php-cli php-common php-json php-gmp php-fpm php-xmlrpc php-bcmath php-imagick php-curl php-zip php-gd php-mysql php-xml php-mbstring php-xmlrpc php-intl php-pgsql
Verifica la versión de PHP instalada.
$ php --version
PHP 8.2.13 (cli) (built: Nov 21 2023 09:55:59) (NTS gcc x86_64)
Copyright (c) The PHP Group
Zend Engine v4.2.13, Copyright (c) Zend Technologies
with Zend OPcache v8.2.13, Copyright (c), by Zend Technologies
Habilita e inicia el servicio PHP-FPM.
$ sudo systemctl enable php-fpm --now
Verifica el estado del servicio PHP.
$ sudo systemctl status php-fpm
? php-fpm.service - El gestor de procesos PHP FastCGI
Loaded: loaded (/usr/lib/systemd/system/php-fpm.service; enabled; preset: disabled)
Active: active (running) since Mon 2023-12-04 14:05:58 UTC; 6s ago
Main PID: 61410 (php-fpm)
Status: "Listo para manejar conexiones"
Tasks: 6 (limit: 10866)
Memory: 16.6M
CPU: 96ms
CGroup: /system.slice/php-fpm.service
??61410 "php-fpm: master process (/etc/php-fpm.conf)"
??61411 "php-fpm: pool www"
??61412 "php-fpm: pool www"
??61413 "php-fpm: pool www"
??61414 "php-fpm: pool www"
??61415 "php-fpm: pool www"
Paso 4 - Configurar PHP-FPM
Abre php.ini para editar.
$ sudo nano /etc/php.ini
Para establecer los tamaños de carga de archivos, cambia los valores de las variables upload_max_filesize y post_max_size. Este valor decide el tamaño de archivo que puedes cargar en Craft CMS. Para nuestros propósitos, lo estamos estableciendo en 128 MB. Puedes configurarlo a tu gusto.
$ sudo sed -i 's/upload_max_filesize = 2M/upload_max_filesize = 128M/' /etc/php.ini
$ sudo sed -i 's/post_max_size = 8M/post_max_size = 128M/' /etc/php.ini
Configura el límite de memoria de PHP dependiendo de los recursos y requisitos de tu servidor.
$ sudo sed -i 's/memory_limit = 128M/memory_limit = 256M/' /etc/php.ini
Abre el archivo /etc/php-fpm.d/www.conf.
$ sudo nano /etc/php-fpm.d/www.conf
Necesitamos establecer el usuario/grupo Unix de los procesos PHP a nginx. Encuentra las líneas user=www-data y group=www-data en el archivo y cámbialas a nginx.
...
; Usuario/grupo Unix de los procesos
; Nota: El usuario es obligatorio. Si el grupo no se establece, se utilizará el grupo del usuario predeterminado
; será utilizado.
; RPM: usuario de apache elegido para proporcionar acceso a los mismos directorios que httpd
user = nginx
; RPM: Mantener un grupo permitido para escribir en el directorio de registro.
group = nginx
...
Encuentra las líneas listen.owner = nobody, listen.group = nobody, listen.mode = 0660 en el archivo y cámbialas como sigue después de descomentarlas.
; Establecer permisos para el socket unix, si se utiliza uno. En Linux, los permisos de lectura/escritura
; deben establecerse para permitir conexiones desde un servidor web. Muchos
; sistemas derivados de BSD permiten conexiones independientemente de los permisos. El propietario
; y el grupo pueden especificarse ya sea por nombre o por sus IDs numéricos.
; Valores predeterminados: el usuario y el grupo se establecen como el usuario en ejecución
; el modo se establece en 0660
listen.owner = nginx
listen.group = nginx
listen.mode = 0660
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Reinicia el proceso PHP-fpm. Asegúrate de tener Nginx instalado antes de reiniciar el servicio PHP, de lo contrario, fallará ya que no podrá encontrar el grupo nginx.
$ sudo systemctl restart php-fpm
Cambia el grupo del directorio de sesiones de PHP a Nginx.
$ sudo chgrp -R nginx /var/lib/php/session
Paso 5 - Instalar Composer
Composer actúa como un gestor de dependencias para PHP. También es el gestor de dependencias del marco PHP Laravel, que es lo que potencia Craft CMS.
Descarga el script de instalación de Composer.
$ php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
Verifica el instalador descargado.
$ php -r "if (hash_file('sha384', 'composer-setup.php') === 'e21205b207c3ff031906575712edab6f13eb0b361f2085f1f1237b7126d785e826a450292b6cfd1d64d92e6563bbde02') { echo 'Instalador verificado'; } else { echo 'Instalador corrupto'; unlink('composer-setup.php'); } echo PHP_EOL;"
Recibirás la siguiente salida.
Instalador verificado
Ejecuta el script de instalación para descargar la última versión de Composer.
$ php composer-setup.php
Elimina el script de instalación.
$ php -r "unlink('composer-setup.php');"
Mueve el archivo binario descargado al directorio /usr/local/bin.
$ sudo mv composer.phar /usr/local/bin/composer
Confirma la instalación.
$ composer --version
Composer version 2.6.5 2023-10-06 10:11:52
Paso 6 - Instalar y Configurar PostgreSQL
Rocky Linux 9 viene con PostgreSQL 13 por defecto. Sin embargo, utilizaremos PostgreSQL 16 en su lugar desde su repositorio oficial.
Instala el repositorio RPM de PostgreSQL.
$ sudo dnf install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-9-x86_64/pgdg-redhat-repo-latest.noarch.rpm
Desactiva el módulo PostgreSQL incorporado.
$ sudo dnf -qy module disable postgresql
Ahora, puedes instalar PostgreSQL usando el siguiente comando.
$ sudo dnf install -y postgresql16-server postgresql16-contrib
El paquete postgresql-contrib contiene algunas utilidades adicionales.
Verifica la versión.
$ psql --version
psql (PostgreSQL) 16.1
Inicializa la base de datos de PostgreSQL.
$ sudo /usr/pgsql-16/bin/postgresql-16-setup initdb
Inicializando base de datos ... OK
Habilita el servicio de PostgreSQL.
$ sudo systemctl enable postgresql-16
Inicia el servicio de PostgreSQL.
$ sudo systemctl start postgresql-16
Verifica el estado del servicio de PostgreSQL.
$ sudo systemctl status postgresql-16
? postgresql-16.service - Servidor de base de datos PostgreSQL 16
Loaded: loaded (/usr/lib/systemd/system/postgresql-16.service; enabled; preset: disabled)
Active: active (running) since Mon 2023-12-04 22:28:34 UTC; 2s ago
Docs: https://www.postgresql.org/docs/16/static/
Process: 72143 ExecStartPre=/usr/pgsql-16/bin/postgresql-16-check-db-dir ${PGDATA} (code=exited, status=0/SUCCESS)
Main PID: 72148 (postgres)
Tasks: 7 (limit: 10866)
Memory: 17.4M
CPU: 45ms
CGroup: /system.slice/postgresql-16.service
??72148 /usr/pgsql-16/bin/postgres -D /var/lib/pgsql/16/data/
??72149 "postgres: logger "
??72150 "postgres: checkpointer "
??72151 "postgres: background writer "
??72153 "postgres: walwriter "
??72154 "postgres: autovacuum launcher "
??72155 "postgres: logical replication launcher "
Dec 04 22:28:33 craftcms.nspeaks.com systemd[1]: Starting PostgreSQL 16 database server...
Dec 04 22:28:33 craftcms.nspeaks.com postgres[72148]: 2023-12-04 22:28:33.999 UTC [72148] LOG: redirecting log output to logging collector process
Dec 04 22:28:33 craftcms.nspeaks.com postgres[72148]: 2023-12-04 22:28:33.999 UTC [72148] HINT: Future log output will appear in directory "log".
Dec 04 22:28:34 craftcms.nspeaks.com systemd[1]: Started PostgreSQL 16 database server.
Puedes ver que el servicio está habilitado y en ejecución por defecto.
Lanza la shell de PostgreSQL.
$ sudo -i -u postgres psql
Crea la base de datos Craft CMS.
postgres=# CREATE DATABASE craftcms;
Crea el usuario de Craft CMS y elige una contraseña fuerte.
postgres-# CREATE USER craftuser WITH PASSWORD 'Your_Password';
Cambia el propietario de la base de datos al usuario de Craft CMS.
postgres-# ALTER DATABASE craftcms OWNER TO craftuser;
Concede todos los privilegios en la base de datos al usuario de Craft CMS.
postgres-# GRANT ALL PRIVILEGES ON DATABASE craftcms TO craftuser;
Sal de la shell.
postgres-# \q
Verifica que tus credenciales funcionen.
$ psql --username craftuser --password --host localhost craftcms
Password:
psql (16.1)
Type "help" for help.
craftcms=>
Sal de la shell escribiendo \q.
Paso 7 - Instalar y Configurar Redis
Rocky Linux 9 viene con Redis 6.2 por defecto. Sin embargo, utilizaremos Redis 7.0 que instalaremos usando el Repositorio Remi.
Dado que hemos instalado el repositorio Remi al instalar PHP, podemos omitir esa parte. Lista todos los módulos Redis disponibles.
$ sudo dnf module list redis
Rocky Linux 9 - AppStream
Name Stream Profiles Summary
redis 7 common [d] Redis persistent key-value database
Remi's Modular repository for Enterprise Linux 9 - x86_64
Name Stream Profiles Summary
redis remi-5.0 common [d] Redis persistent key-value database
redis remi-6.0 common [d] Redis persistent key-value database
redis remi-6.2 common [d] Redis persistent key-value database
redis remi-7.0 common [d] Redis persistent key-value database
redis remi-7.2 common [d] Redis persistent key-value database
Hint: [d]efault, [e]nabled, [x]disabled, [i]nstalled
Habilita el módulo Redis 7.2 más reciente.
$ sudo dnf module enable -y redis:remi-7.2
Instala Redis.
$ sudo dnf install redis
Verifica la versión.
$ redis-server --version
Redis server v=7.2.3 sha=00000000:0 malloc=jemalloc-5.3.0 bits=64 build=7bd3173e4e30c3e4
Habilita el servicio de Redis.
$ sudo systemctl enable redis
Inicia el servicio de Redis.
$ sudo systemctl start redis
Verifica el estado del servicio.
$ sudo systemctl status redis
? redis.service - Base de datos clave-valor persistente Redis
Loaded: loaded (/usr/lib/systemd/system/redis.service; enabled; preset: disabled)
Drop-In: /etc/systemd/system/redis.service.d
??limit.conf
Active: active (running) since Mon 2023-12-04 22:36:25 UTC; 1min 32s ago
Main PID: 72877 (redis-server)
Status: "Listo para aceptar conexiones"
Tasks: 5 (limit: 10866)
Memory: 7.5M
CPU: 176ms
CGroup: /system.slice/redis.service
??72877 "/usr/bin/redis-server 127.0.0.1:6379"
Dec 04 22:36:25 craftcms.nspeaks.com systemd[1]: Starting Redis persistent key-value database...
Dec 04 22:36:25 craftcms.nspeaks.com systemd[1]: Started Redis persistent key-value database.
El siguiente paso es agregar autenticación al servidor Redis. Desde Redis v6.0, la mejor manera de agregar autenticación es usar ACL (Listas de Control de Acceso). Abre el archivo /etc/redis/redis.conf para editar.
$ sudo nano /etc/redis/redis.conf
Encuentra la línea # aclfile /etc/redis/users.acl y descoméntala eliminando el hash (#) que está delante de ella.
aclfile /etc/redis/users.acl
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
A continuación, crea y abre el archivo /etc/redis/users.acl para editar.
$ sudo nano /etc/redis/users.acl
Agrega la siguiente línea a él.
user navjot on +@all ~* >yourpassword
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Reinicia el servidor Redis para implementar el cambio.
$ sudo systemctl restart redis
Abre la shell de Redis.
$ redis-cli
Usa el comando PING. Te dará un error de autenticación.
127.0.0.1:6379> PING
(error) NOAUTH Authentication required.
Usa el comando AUTH para iniciar sesión.
127.0.0.1:6379> AUTH navjot yourpassword
OK
Usa el comando PING nuevamente.
127.0.0.1:6379> PING
OK
Sal de la shell.
127.0.0.1:6379> exit
También necesitarás instalar la extensión PHP Redis.
$ sudo apt install php-redis
Paso 8 - Instalar Craft CMS
Antes de instalar Craft CMS, puedes verificar si cumples con todos los requisitos del servidor para ejecutarlo usando el siguiente comando.
$ curl -Lsf https://raw.githubusercontent.com/craftcms/server-check/HEAD/check.sh | bash
Recibirás la siguiente salida.
Ejecutando verificación del servidor Craft...
Verificador de requisitos de Craft CMS
Este script verifica si la configuración de tu servidor web cumple con los requisitos para ejecutar una instalación de Craft CMS.
Verifica si el servidor está ejecutando la versión correcta de PHP, si se han cargado las extensiones PHP apropiadas,
y si la configuración del archivo php.ini es correcta.
Resultados:
--------
PHP 8.2+: OK
BCMath extension: OK
ctype extension: OK
cURL extension: OK
DOM extension: OK
Fileinfo extension: OK
GD extension or ImageMagick extension: OK
iconv extension: OK
Intl extension: OK
JSON extension: OK
Multibyte String extension (with Function Overloading disabled): OK
OPcache extension (with save_comments): OK
OpenSSL extension: OK
PCRE extension (with UTF-8 support): OK
PDO extension: OK
Reflection extension: OK
SPL extension: OK
Zip extension: OK
ignore_user_abort(): OK
password_hash(): OK
proc_close(): OK
proc_get_status(): OK
proc_open(): OK
proc_terminate(): OK
allow_url_fopen: OK
ini_set calls: OK
Memory Limit: OK
------------------------------------------
Errores: 0 Advertencias: 0 Total de verificaciones: 27
Una vez que todo esté bien, puedes proceder. Crea el directorio raíz web.
$ sudo mkdir /var/www/html/craftcms -p
Establece al usuario actualmente conectado como el propietario de este directorio.
$ sudo chown -R $USER:$USER /var/www/html/craftcms
Cambia al directorio.
$ cd /var/www/html/craftcms
Descarga e instala Craft CMS usando Composer. El punto (.) al final del comando significa que la instalación debe realizarse en el directorio actual.
$ composer create-project craftcms/craft .
Durante la instalación, se te pedirá varios detalles sobre la base de datos, y la cuenta de administrador. URL del sitio y su idioma como se muestra a continuación.
> @php craft setup/welcome
______ .______ ___ _______ .___________.
/ || _ \ / \ | ____|| |
| ,----'| |_) | / ^ \ | |__ `---| |----`
| | | / / /_\ \ | __| | |
| `----.| |\ \----./ _____ \ | | | |
\______|| _| `._____/__/ \__\ |__| |__|
A N E W I N S T A L L
______ .___ ___. _______.
/ || \/ | / |
| ,----'| \ / | | (----`
| | | |\/| | \ \
| `----.| | | | .----) |
\______||__| |__| |_______|
Generando un ID de aplicación ... hecho (CraftCMS--923f03f1-9bea-4c3d-a7ca-1466645ce75d)
Generando una clave de seguridad ... hecho (iMdcUi6wQyf9MshEda__vZcCwILbclxz)
¡Bienvenido a Craft CMS!
¿Estás listo para comenzar la configuración? (yes|no) [no]:yes
¿Qué controlador de base de datos estás usando? (mysql o pgsql) [mysql] pgsql
Nombre o dirección IP del servidor de base de datos: [127.0.0.1]
Puerto de base de datos: [5432]
Nombre de usuario de base de datos: [root] craftuser
Contraseña de base de datos:
Nombre de la base de datos: craftcms
Prefijo de tabla de base de datos:
Probando credenciales de base de datos ... ¡éxito!
Usando esquema predeterminado "public".
Guardando credenciales de base de datos en tu archivo .env ... hecho
¿Instalar Craft ahora? (yes|no) [yes]:yes
Nombre de usuario: [admin] navjot
Correo electrónico: [email protected]
Contraseña:
Confirmar:
Nombre del sitio: Howtoforge Tutorials
URL del sitio: https://craftcms.example.com
Idioma del sitio: [en-US]
*** instalando Craft
Hacer que Redis funcione con Craft CMS
Instala el paquete yiisoft/yii2-redis.
$ composer require --prefer-dist yiisoft/yii2-redis:"~2.0.0"
Abre el archivo /var/www/html/craftcms/config/app.php para editar.
$ nano config/app.php
Verás el siguiente contenido en él.
use craft\helpers\App;
return [
'id' => App::env('CRAFT_APP_ID') ?: 'CraftCMS',
];
Cámbialo como sigue.
use craft\helpers\App;
return [
'id' => App::env('CRAFT_APP_ID') ?: 'CraftCMS',
'components' => [
'cache' => function() {
$config = [
'class' => yii\redis\Cache::class,
'keyPrefix' => Craft::$app->id,
'defaultDuration' => Craft::$app->config->general->cacheDuration,
// Detalles completos de conexión a Redis:
'redis' => [
'hostname' => App::env('REDIS_HOSTNAME') ?: 'localhost',
'port' => 6379,
'username' => App::env('REDIS_USERNAME') ?: null,
'password' => App::env('REDIS_PASSWORD') ?: null,
],
];
return Craft::createObject($config);
},
],
];
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida. Esto habilita Redis como almacenamiento en caché para Craft CMS. También puedes usar Redis para almacenar datos de sesión de PHP, cola de trabajos y como controlador de mutex. Puedes encontrar la configuración para ello en la documentación de Craft CMS.
También necesitas agregar la configuración de Redis al archivo .env.
$ nano .env
Agrega el siguiente código al final del archivo.
REDIS_HOSTNAME=localhost
REDIS_USERNAME=navjot
REDIS_PASSWORD=yourpassword
Elige las opciones como se muestra arriba. Una vez terminado, cambia el grupo del directorio a nginx. De esta manera, tanto el usuario actualmente conectado como Nginx tendrán acceso a Craft CMS.
$ sudo chgrp -R nginx /var/www/html/craftcms
Dale permiso al grupo nginx para escribir en el directorio.
$ sudo chmod -R g+w /var/www/html/craftcms
A partir de aquí, no necesitarás cambiar los permisos nuevamente y podrás realizar todas las operaciones sin usar privilegios de root.
Paso 9 - Instalar SSL
Necesitamos instalar Certbot para generar el certificado SSL. Usaremos el instalador de paquetes Snapd para eso. Dado que Rocky Linux no lo incluye, instala el instalador Snapd. Requiere el repositorio EPEL (Paquetes Adicionales para Linux Empresarial) para funcionar. Pero como ya lo instalamos en el paso 3, podemos avanzar directamente.
Instala Snapd.
$ sudo dnf install -y snapd
Habilita e inicia el servicio Snap.
$ sudo systemctl enable snapd --now
Instala el paquete base de Snap, y asegúrate de que tu versión de Snapd esté actualizada.
$ sudo snap install core && sudo snap refresh core
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
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 si Certbot está funcionando correctamente.
$ certbot --version
certbot 2.7.4
Ejecuta el siguiente comando para generar un certificado SSL.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d craftcms.example.com
El comando anterior descargará un certificado en el directorio /etc/letsencrypt/live/craftcms.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
---------------------------------------------------------------------------------------------------------------------------
Mon 2023-12-04 23:38:47 UTC 18min left Mon 2023-12-04 22:19:02 UTC 1h 0min ago dnf-makecache.timer dnf-makecache.service
Tue 2023-12-05 00:00:00 UTC 40min left - - logrotate.timer logrotate.service
Tue 2023-12-05 09:36:00 UTC 10h left - - snap.certbot.renew.timer snap.certbot.renew.service
Haz una prueba del proceso para verificar si la renovación de SSL está funcionando correctamente.
$ sudo certbot renew --dry-run
Si no ves errores, estás listo. Tu certificado se renovará automáticamente.
Paso 10 - Configurar SELinux
Cambia el contexto de seguridad del archivo para Craft CMS.
$ sudo semanage fcontext -a -t httpd_sys_rw_content_t "/var/www/html/craftcms(/.*)?"
Aplica la política.
$ sudo restorecon -Rv /var/www/html/craftcms/
Aplica la política para permitir que Nginx tenga acceso a PostgreSQL.
$ sudo setsebool -P httpd_can_network_connect_db 1
Aplica la política para permitir que se realicen conexiones a hosts externos.
$ sudo setsebool -P httpd_can_network_connect 1
Con MariaDB 10.11, enfrentarás otro problema que es que SELinux impide que PHP-FPM se conecte a MariaDB. Eso se puede resolver instalando un módulo SELinux. El primer paso es crear un archivo de tipo de aplicación.
Crea el archivo my-phpfpm.te en tu directorio personal y ábrelo para editar.
$ cd ~
$ nano my-phpfpm.te
Pega el siguiente código en él.
module my-phpfpm 1.0;
require {
type unconfined_service_t;
type httpd_t;
type httpd_sys_content_t;
class dir write;
class unix_stream_socket connectto;
}
#============= httpd_t ==============
#!!!! Este avc está permitido en la política actual
allow httpd_t httpd_sys_content_t:dir write;
#!!!! Este avc está permitido en la política actual
allow httpd_t unconfined_service_t:unix_stream_socket connectto;
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
El siguiente paso es convertirlo en un módulo de política usando el siguiente comando. No modifiques el nombre del archivo en el comando, de lo contrario, no funcionará. El módulo se llama my-phpfpm y el nombre del archivo debe ser el mismo que el nombre del módulo.
$ sudo checkmodule -M -m -o my-phpfpm.mod my-phpfpm.te
A continuación, necesitamos compilar el módulo de política para crear un paquete de política.
$ sudo semodule_package -o my-phpfpm.pp -m my-phpfpm.mod
El paso final es cargar el paquete de política usando el comando semodule que instala la política para ser utilizada.
$ sudo semodule -i my-phpfpm.pp
Paso 11 - Configurar Nginx
Abre el archivo /etc/nginx/nginx.conf para editar.
$ 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.
Crea y abre el archivo /etc/nginx/conf.d/craftcms.conf para editar.
$ sudo nano /etc/nginx/conf.d/craftcms.conf
Pega el siguiente código en él. Reemplaza craftcms.example.com con tu nombre de dominio. Asegúrate de que el valor de client_max_body_size esté establecido en 128MB, que es lo que configuramos para Craft CMS al configurar PHP anteriormente.
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
server_name craftcms.example.com;
root /var/www/html/craftcms/web;
index index.php;
client_max_body_size 128M;
access_log /var/log/nginx/craftcms.access.log;
error_log /var/log/nginx/craftcms.error.log;
ssl_certificate /etc/letsencrypt/live/craftcms.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/craftcms.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/craftcms.example.com/chain.pem;
ssl_session_timeout 5m;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_prefer_server_ciphers on;
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;
ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
location / {
try_files $uri/index.html $uri $uri/ /index.php?$query_string;
}
location ~ [^/]
.php(/|$) {
try_files $uri $uri/ /index.php?$query_string;
fastcgi_index index.php;
fastcgi_split_path_info ^(.+\.php)(/.+)$;
fastcgi_keep_conn on;
include fastcgi_params;
fastcgi_pass unix:/run/php-fpm/www.sock;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_param PATH_INFO $fastcgi_path_info;
fastcgi_param HTTP_PROXY "";
}
}
# forzar HTTPS
server {
listen 80;
listen [::]:80;
server_name craftcms.example.com;
return 301 https://$host$request_uri;
}
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Verifica tu configuración de Nginx.
$ sudo nginx -t
Reinicia el servidor Nginx.
$ sudo systemctl restart nginx
Paso 12 - Acceder a Craft CMS
Abre la URL https://craftcms.example.com en tu navegador y serás llevado a la siguiente página.
Para acceder a la página de administración, visita la URL https://craftcms.example.com/admin y serás llevado a la página de inicio de sesión.
Ingresa tus credenciales de administración y haz clic en la tecla Iniciar sesión para acceder. Serás llevado al siguiente panel de control.
Ahora puedes comenzar a usar Craft CMS para construir tu sitio web.
Paso 13 - Hacer copias de seguridad y restaurar Craft CMS
Puedes hacer una copia de seguridad de la base de datos de Craft CMS desde dentro del panel de administración visitando Panel de administración >> Utilidades >> Copia de seguridad de la base de datos.
Haz clic en el botón Copia de seguridad para descargar tu copia de seguridad de la base de datos. También puedes crear la copia de seguridad usando la terminal. Ejecuta el siguiente comando para crear la copia de seguridad. Ingresa tu contraseña cuando se te pida.
$ mysqldump -u craftcmsuser -p craftcms > ~/craftcms.database.sql
También puedes crear la copia de seguridad de la base de datos usando la utilidad de línea de comandos de Craft CMS. La ventaja de esta utilidad es que no necesitas pasar tus credenciales de base de datos. Lee más sobre la utilidad de consola de comandos de Craft CMS aquí.
$ cd /var/www/html/craftcms
$ php craft db/backup ~/
Haciendo copia de seguridad de la base de datos ... hecho
Archivo de copia de seguridad: /home/navjot/howtoforge-tutorials--2023-12-03-065138--v4.5.11.1.sql (200.019 KB)
Si no especificas ninguna ubicación en el comando anterior, el archivo de copia de seguridad se escribirá en el directorio /var/www/html/craftcms/storage/backups.
Para hacer una copia de seguridad de los archivos, copia y guarda toda la carpeta /var/www/html/craftcms.
$ cd /var/www/html
$ tar -zcf ~/craftcms.tar.gz craftcms
Para restaurarlo en un nuevo servidor, extrae los archivos en la carpeta /var/www/html.
$ tar -xzf craftcms.tar.gz -C /var/www/html/
Crea una base de datos con las mismas credenciales en el nuevo servidor y restaura la base de datos usando el siguiente comando. Ingresa tu contraseña cuando se te pida.
$ mysqlimport -u craftcmsuser -p craftcms craftcms.database.sql
Paso 14 - Actualizar Craft CMS
Hay dos formas de actualizar Craft CMS. Una es desde dentro del panel de administración. Cuando hay una actualización disponible, recibirás un aviso. Haz clic en el aviso para actualizar. Craft CMS hará automáticamente una copia de seguridad de la base de datos antes de realizar una actualización.
También puedes actualizarlo a través de la terminal.
Para verificar todas las actualizaciones disponibles, ejecuta el siguiente comando.
$ cd /var/www/html/craftcms/
$ php craft update
Si hay una actualización disponible, ejecuta el siguiente comando para aplicarla.
$ php craft update all
Conclusión
Esto concluye nuestro tutorial donde aprendiste cómo instalar el software Craft CMS en un servidor Debian 12. Si tienes alguna pregunta, publícalas en los comentarios a continuación.
Recibe nuevas publicaciones en tu bandeja de entrada.
No spam. Cancela la suscripción en cualquier momento.