Instalación CMS · 19 min read · Oct 23, 2025

Cómo instalar Craft CMS en Debian 12

Craft CMS es un sistema de gestión de contenido de código abierto para crear todo tipo de 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 framework Yii PHP. El motor de plantillas Twig impulsa 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 Debian 12 con un mínimo de 1 GB de RAM.
  • Un usuario no root con privilegios de sudo.
  • El Firewall sin complicaciones (UFW) está habilitado y en funcionamiento.
  • Un Nombre de Dominio Totalmente Calificado (FQDN) como craftcms.example.com apuntando a tu servidor.
  • Una cuenta SMTP con un servicio de correo electrónico como Amazon SES o Mailgun.
  • Todo está actualizado. $ sudo apt update && sudo apt upgrade
  • Se requieren algunos paquetes esenciales para que el tutorial y Craft CMS funcionen. Algunos de estos ya estarán en tu servidor. $ sudo apt install curl wget nano software-properties-common dirmngr apt-transport-https ca-certificates lsb-release debian-archive-keyring gnupg2 ufw unzip -y

Paso 1 - Configurar el Firewall

El primer paso antes de instalar cualquier paquete es configurar el firewall para permitir conexiones HTTP y HTTPS.

Verifica el estado del firewall.

$ sudo ufw status

Deberías ver algo como lo siguiente.

Estado: activo

Para                         Acción      Desde
--                         ------      ----
OpenSSH                    PERMITIR       En cualquier lugar
OpenSSH (v6)               PERMITIR       En cualquier lugar (v6)

Permitir los puertos HTTP y HTTPS.

$ sudo ufw allow http
$ sudo ufw allow https

Verifica el estado nuevamente para confirmar.

$ sudo ufw status
Estado: activo

Para                         Acción      Desde
--                         ------      ----
OpenSSH                    PERMITIR       En cualquier lugar
80/tcp                     PERMITIR       En cualquier lugar
443/tcp                    PERMITIR       En cualquier lugar
OpenSSH (v6)               PERMITIR       En cualquier lugar (v6)
80/tcp (v6)                PERMITIR       En cualquier lugar (v6)
443/tcp (v6)               PERMITIR       En cualquier lugar (v6)

Paso 2 - Instalar Nginx

Debian 12 viene con una versión más antigua de Nginx. Necesitas descargar el repositorio oficial de Nginx para instalar la última versión.

Importa la clave de firma de Nginx.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
    | sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Agrega el repositorio para la versión estable de Nginx.

$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg] \
http://nginx.org/packages/debian `lsb_release -cs` nginx" \
    | sudo tee /etc/apt/sources.list.d/nginx.list

Actualiza los repositorios del sistema.

$ sudo apt update

Instala Nginx.

$ sudo apt install nginx

Verifica la instalación. En sistemas Debian, el siguiente comando solo funcionará con sudo.

$ sudo nginx -v
nginx version: nginx/1.24.0

Inicia el servidor Nginx.

$ sudo systemctl start nginx

Verifica el estado del servicio.

$ sudo systemctl status nginx
? nginx.service - nginx - servidor web de alto rendimiento
     Cargado: cargado (/lib/systemd/system/nginx.service; habilitado; preestablecido: habilitado)
     Activo: activo (en ejecución) desde Vie 2023-12-01 09:46:46 UTC; hace 18s
       Docs: https://nginx.org/en/docs/
    Proceso: 39483 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (código=salió, estado=0/ÉXITO)
   PID principal: 39484 (nginx)
      Tareas: 2 (límite: 2315)
     Memoria: 1.7M
        CPU: 6ms
     CGroup: /system.slice/nginx.service
             ??39484 "nginx: proceso maestro /usr/sbin/nginx -c /etc/nginx/nginx.conf"
             ??39485 "nginx: proceso trabajador"

Paso 3 - Instalar PHP y extensiones

Debian 12 viene con PHP 8.2 por defecto. Puedes instalarlo y las extensiones requeridas por Craft CMS ejecutando el siguiente comando.

$ sudo apt 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

Para mantenerte siempre en la última versión de PHP o si deseas instalar múltiples versiones de PHP, agrega el repositorio PHP de Ondrej.

Primero, importa la clave GPG del repositorio PHP de Sury.

$ sudo curl -sSLo /usr/share/keyrings/deb.sury.org-php.gpg https://packages.sury.org/php/apt.gpg

Agrega el repositorio PHP de Ondrej Sury.

$ sudo sh -c 'echo "deb [signed-by=/usr/share/keyrings/deb.sury.org-php.gpg] https://packages.sury.org/php/ $(lsb_release -sc) main" > /etc/apt/sources.list.d/php.list'

Actualiza tu lista de repositorios del sistema.

$ sudo apt update

Probablemente recibirás información sobre actualizaciones pendientes. Ejecútalas.

$ sudo apt upgrade

Instala PHP y sus extensiones.

$ sudo apt install php8.2 php8.2-cli php8.2-common php8.2-gmp php8.2-fpm php8.2-xmlrpc php8.2-bcmath php8.2-imagick php8.2-curl php8.2-zip php8.2-gd php8.2-mysql php8.2-xml php8.2-mbstring php8.2-xmlrpc php8.2-intl php8.2-pgsql

Verifica la versión de PHP instalada.

$ php --version
PHP 8.2.13 (cli) (compilado: Nov 24 2023 13:10:42) (NTS)
Copyright (c) El Grupo PHP
Zend Engine v4.2.13, Copyright (c) Tecnologías Zend
    con Zend OPcache v8.2.13, Copyright (c), por Tecnologías Zend

Verifica el estado del servicio PHP.

$ sudo systemctl status php8.2-fpm
? php8.2-fpm.service - El gestor de procesos FastCGI de PHP 8.2
     Cargado: cargado (/lib/systemd/system/php8.2-fpm.service; habilitado; preestablecido: habilitado)
     Activo: activo (en ejecución) desde Vie 2023-12-01 10:29:53 UTC; hace 34min
       Docs: man:php-fpm8.2(8)
    Proceso: 65825 ExecStartPost=/usr/lib/php/php-fpm-socket-helper install /run/php/php-fpm.sock /etc/php/8.2/fpm/pool.d/www.conf 82 (código=salió, estado=0/ÉXITO)
   PID principal: 65821 (php-fpm8.2)
     Estado: "Procesos activos: 0, inactivos: 3, Solicitudes: 208, lentas: 0, Tráfico: 0.2req/sec"
      Tareas: 4 (límite: 2315)
     Memoria: 83.4M
        CPU: 6.456s
     CGroup: /system.slice/php8.2-fpm.service
             ??65821 "php-fpm: proceso maestro (/etc/php/8.2/fpm/php-fpm.conf)"
             ??65823 "php-fpm: pool www"
             ??65824 "php-fpm: pool www"
             ??65843 "php-fpm: pool www"

Paso 4 - Configurar PHP-FPM

Abre php.ini para editar.

$ sudo nano /etc/php/8.2/fpm/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/8.2/fpm/php.ini
$ sudo sed -i 's/post_max_size = 8M/post_max_size = 128M/' /etc/php/8.2/fpm/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/8.2/fpm/php.ini

Abre el archivo /etc/php/8.2/fpm/pool.d/www.conf.

$ sudo nano /etc/php/8.2/fpm/pool.d/www.conf

Necesitamos establecer el usuario/grupo Unix de los procesos PHP en 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 está establecido, se utilizará el grupo del usuario predeterminado
;       será utilizado.
user = nginx
group = nginx
...

Además, encuentra las líneas listen.owner=www-data y listen.group=www-data en el archivo y cámbialas a nginx.

listen.owner = nginx
listen.group = nginx

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 php8.2-fpm

Paso 5 - Instalar Composer

Composer actúa como un gestor de dependencias para PHP. También es el gestor de dependencias del framework PHP Laravel, que es lo que impulsa 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

Debian 12 viene con PostgreSQL 15 por defecto. Usaremos PostgreSQL 16 en su lugar.

Ejecuta el siguiente comando para agregar la clave GPG de PostgreSQL.

$ curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | gpg --dearmor | sudo tee /usr/share/keyrings/postgresql-key.gpg >/dev/null

Agrega el repositorio APT a tu lista de fuentes.

$ sudo sh -c 'echo "deb [signed-by=/usr/share/keyrings/postgresql-key.gpg arch=amd64] http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'

Actualiza el repositorio del sistema.

$ sudo apt update

Ahora puedes instalar PostgreSQL usando el siguiente comando.

$ sudo apt install postgresql postgresql-contrib

El paquete postgresql-contrib contiene algunas utilidades adicionales.

Verifica la versión.

$ psql --version
psql (PostgreSQL) 16.1 (Debian 16.1-1.pgdg120+1)

Verifica el estado del servicio PostgreSQL.

$ sudo systemctl status postgresql
? postgresql.service - RDBMS de PostgreSQL
     Cargado: cargado (/lib/systemd/system/postgresql.service; habilitado; preestablecido: habilitado)
     Activo: activo (salió) desde Mié 2023-11-29 05:54:03 UTC; hace 11s
   PID principal: 20170 (código=salió, estado=0/ÉXITO)
        CPU: 1ms

Nov 29 05:54:03 craftcms systemd[1]: Iniciando postgresql.service - RDBMS de PostgreSQL...
Nov 29 05:54:03 craftcms systemd[1]: Finalizado postgresql.service - RDBMS de PostgreSQL.

Puedes ver que el servicio está habilitado y en ejecución por defecto.

Lanza la consola 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;

Otorga 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 consola.

postgres-# \q

Verifica que tus credenciales funcionen.

$ psql --username craftuser --password --host localhost craftcms
Contraseña:
psql (16.1 (Debian 16.1-1.pgdg120+1))
Conexión SSL (protocolo: TLSv1.3, cifrado: TLS_AES_256_GCM_SHA384, compresión: apagada)
Escribe "help" para ayuda.

craftcms=>

Sal de la consola escribiendo \q.

Paso 7 - Instalar y Configurar Redis

Debian 12 viene con Redis 7.0 por defecto, que es lo que usaremos. Instala Redis.

$ sudo apt install redis

Verifica la versión.

$ redis-server --version
Servidor Redis v=7.0.11 sha=00000000:0 malloc=jemalloc-5.3.0 bits=64 build=c4e7f6bf175a885b

Sin embargo, si deseas instalar la última versión, puedes hacerlo utilizando el repositorio oficial de Redis emitiendo los siguientes comandos.

$ curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg
$ echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list
$ sudo apt update
$ sudo apt install redis

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 consola de Redis.

$ redis-cli

Usa el comando PING. Te dará un error de autenticación.

127.0.0.1:6379> PING
(error) NOAUTH Se requiere autenticación.

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

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 utilizando 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 las configuraciones del archivo php.ini son correctas.

Resultados:
--------

PHP 8.2+: OK

Extensión BCMath: OK

Extensión ctype: OK

Extensión cURL: OK

Extensión DOM: OK

Extensión Fileinfo: OK

Extensión GD o extensión ImageMagick: OK

Extensión iconv: OK

Extensión Intl: OK

Extensión JSON: OK

Extensión Multibyte String (con la sobrecarga de funciones desactivada): OK

Extensión OPcache (con save_comments): OK

Extensión OpenSSL: OK

Extensión PCRE (con soporte UTF-8): OK

Extensión PDO: OK

Extensión Reflection: OK

Extensión SPL: OK

Extensión Zip: 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

Límite de memoria: OK

------------------------------------------
Errores: 0   Advertencias: 0   Total de verificaciones: 27

Una vez que todo esté bien, puedes proceder. Crea el directorio raíz del sitio web.

$ sudo mkdir /var/www/html/craftcms -p

Establece al usuario que ha iniciado sesión actualmente 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? (sí|no) [no]:sí
¿Qué controlador de base de datos estás usando? (mysql o pgsql) [mysql] pgsql
Nombre del servidor de base de datos o dirección IP: [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 el esquema predeterminado "public".
Guardando credenciales de base de datos en tu archivo .env ... hecho

¿Instalar Craft ahora? (sí|no) [sí]:sí

Nombre de usuario: [admin] navjot
Correo electrónico: [email protected]
Contraseña:
Confirmar:
Nombre del sitio: Tutoriales de Howtoforge
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 que ha iniciado sesión actualmente 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. Puedes instalar Certbot usando el repositorio de Debian o obtener la última versión usando la herramienta Snapd. Usaremos la versión de Snapd.

Debian 12 no viene con Snapd instalado. Instala el paquete Snapd.

$ sudo apt install snapd

Ejecuta los siguientes comandos para asegurarte de que tu versión de Snapd esté actualizada.

$ 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 pueda ejecutarse 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     
---------------------------------------------------------------------------------------------------------------------------               
Vie 2023-12-01 10:39:00 UTC 12min left   Vie 2023-12-01 10:09:01 UTC 17min ago  phpsessionclean.timer    phpsessionclean.service
Vie 2023-12-01 17:01:47 UTC 6h left      Jue 2023-11-30 17:01:47 UTC 17h ago    systemd-tmpfiles-clean.timer systemd-tmpfiles-clean.service
Vie 2023-12-01 18:34:00 UTC 8h left      -                           -          snap.certbot.renew.timer snap.certbot.renew.service

Haz una prueba en seco 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

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é configurado en 128MB, que es lo que establecimos 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/php8.2-fpm.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 11 - Acceder a Craft CMS

Abre la URL https://craftcms.example.com en tu navegador y serás llevado a la siguiente página.

Página de inicio de Craft CMS

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.

Página de inicio de sesión de Craft CMS

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.

Panel de administración de Craft CMS

Ahora puedes comenzar a usar Craft CMS para construir tu sitio web.

Paso 12 - 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.

Copia de seguridad de la base de datos de Craft CMS

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 utilizando 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, simplemente 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 13 - 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.

Share: X/Twitter LinkedIn
#Instalación CMS

Recibe nuevas publicaciones en tu bandeja de entrada.

No spam. Cancela la suscripción en cualquier momento.