Magento Open Source es una plataforma de comercio electrónico pensada para catálogos grandes, varias tiendas y personalización a medida, y es bastante más exigente con el servidor que otras alternativas. En este tutorial instalarás Magento 2.4.8 en Ubuntu 24.04 con Composer, Nginx, PHP 8.3-FPM, MySQL 8 y OpenSearch como motor de búsqueda. Después configurarás Redis para la caché y las sesiones, el cron, los indexadores y el modo producción, que es donde está la mayor parte de la mejora de rendimiento.

Requisitos previos

Para seguir esta guía necesitas:

  • Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath, con al menos 4 GB de RAM (8 GB recomendados, porque OpenSearch reserva 1 GB solo para él), 2 vCPU y 40 GB de disco SSD.
  • Un usuario no root con privilegios sudo.
  • Un dominio con un registro DNS de tipo A que apunte a la IP del servidor. En la guía se usa your_domain como marcador.
  • Los puertos 22, 80 y 443 abiertos.
  • Unas claves de acceso de Adobe Commerce Marketplace. Créalas gratis en commercemarketplace.adobe.com en My Profile > Access Keys. La clave pública hará de usuario y la privada de contraseña al descargar Magento con Composer.

Magento 2.4.8 admite PHP 8.3 y 8.4 y OpenSearch 2.x. Antes de instalar otra versión, consulta sus requisitos del sistema en la documentación de Adobe, porque cambian entre versiones menores.

Paso 1: Instalar Nginx, PHP 8.3 y MySQL

Instala Nginx, MySQL 8 y PHP 8.3-FPM con todas las extensiones que Magento necesita. Ubuntu 24.04 incluye PHP 8.3 en sus repositorios, así que no hacen falta repositorios externos:

sudo apt update
sudo apt install -y nginx mysql-server unzip curl \
  php8.3-fpm php8.3-cli php8.3-mysql php8.3-bcmath php8.3-curl php8.3-gd \
  php8.3-intl php8.3-mbstring php8.3-soap php8.3-xml php8.3-zip php8.3-redis

Comprueba que las extensiones críticas están cargadas:

php -m | grep -Ei '^(bcmath|intl|pdo_mysql|soap|sodium|xsl|zip|gd)$'

bcmath
gd
intl
pdo_mysql
soap
sodium
xsl
zip

Paso 2: Ajustar PHP para Magento

Magento necesita mucha más memoria y más caché de código que una aplicación PHP típica. opcache.save_comments debe estar activado porque Magento lee anotaciones de los comentarios del código. Crea un archivo de configuración propio:

sudo nano /etc/php/8.3/fpm/conf.d/99-magento.ini

memory_limit = 2G
max_execution_time = 1800
zlib.output_compression = On
realpath_cache_size = 10M
realpath_cache_ttl = 7200

opcache.enable = 1
opcache.memory_consumption = 512
opcache.interned_strings_buffer = 32
opcache.max_accelerated_files = 60000
opcache.save_comments = 1

Los comandos bin/magento usan PHP CLI, que lee otra configuración. Enlaza el mismo archivo para la CLI, así la compilación y el despliegue de estáticos no se quedan sin memoria:

sudo ln -s /etc/php/8.3/fpm/conf.d/99-magento.ini /etc/php/8.3/cli/conf.d/99-magento.ini
sudo systemctl restart php8.3-fpm

Comprueba los valores en ambos entornos:

php -i | grep -E '^(memory_limit|opcache.save_comments)'
sudo php-fpm8.3 -i | grep -E '^(memory_limit|opcache.memory_consumption)'

memory_limit => 2G => 2G
opcache.save_comments => On => On
memory_limit => 2G => 2G
opcache.memory_consumption => 512 => 512

Paso 3: Crear la base de datos

MySQL 8 tiene el registro binario activado por defecto y, con él, impide que un usuario sin privilegio SUPER cree los triggers que Magento usa para la indexación. Permite la creación de triggers con un archivo de configuración propio:

sudo nano /etc/mysql/mysql.conf.d/99-magento.cnf

[mysqld]
log_bin_trust_function_creators = 1
innodb_buffer_pool_size = 1G

innodb_buffer_pool_size es la memoria que MySQL dedica a mantener datos e índices; 1 GB es un buen punto de partida en un servidor de 8 GB compartido con PHP y OpenSearch. Reinicia MySQL:

sudo systemctl restart mysql

Crea la base de datos y un usuario dedicado. Sustituye your_strong_password por una contraseña robusta:

sudo mysql

CREATE DATABASE magento;
CREATE USER 'magento'@'localhost' IDENTIFIED BY 'your_strong_password';
GRANT ALL PRIVILEGES ON magento.* TO 'magento'@'localhost';
FLUSH PRIVILEGES;
EXIT;

Comprueba que el usuario puede conectarse:

mysql -u magento -p -e "SHOW DATABASES;"

+--------------------+
| Database           |
+--------------------+
| information_schema |
| magento            |
| performance_schema |
+--------------------+

Paso 4: Ejecutar OpenSearch

Magento 2.4 necesita un motor de búsqueda externo para el catálogo. La forma más sencilla de mantener OpenSearch en un único servidor es ejecutar la imagen oficial en un contenedor. Instala Docker desde los repositorios de Ubuntu:

sudo apt install -y docker.io
sudo systemctl enable --now docker

OpenSearch necesita un valor alto de vm.max_map_count. Configúralo de forma persistente:

echo "vm.max_map_count=262144" | sudo tee /etc/sysctl.d/99-opensearch.conf
sudo sysctl --system

Arranca OpenSearch como nodo único, con 1 GB de memoria y un volumen para los datos. El puerto se publica solo en 127.0.0.1: como no es accesible desde fuera del servidor, el plugin de seguridad (autenticación y TLS) se desactiva para simplificar la conexión desde Magento:

sudo docker run -d --name opensearch --restart unless-stopped \
  -p 127.0.0.1:9200:9200 \
  -e "discovery.type=single-node" \
  -e "DISABLE_SECURITY_PLUGIN=true" \
  -e "DISABLE_INSTALL_DEMO_CONFIG=true" \
  -e "OPENSEARCH_JAVA_OPTS=-Xms1g -Xmx1g" \
  -v opensearch-data:/usr/share/opensearch/data \
  opensearchproject/opensearch:2.19.1

Espera unos 30 segundos y comprueba que responde:

curl -s http://127.0.0.1:9200

{
  "name" : "a1b2c3d4e5f6",
  "cluster_name" : "docker-cluster",
  "version" : {
    "distribution" : "opensearch",
    "number" : "2.19.1",
    ...
  },
  "tagline" : "The OpenSearch Project: https://opensearch.org/"
}

Paso 5: Instalar Composer

Instala la versión actual de Composer 2 con el instalador oficial, comprobando antes su firma SHA-384:

cd ~
curl -fsSL https://getcomposer.org/installer -o composer-setup.php
EXPECTED="$(curl -fsSL https://composer.github.io/installer.sig)"
echo "${EXPECTED}  composer-setup.php" | sha384sum -c -

composer-setup.php: OK

Si la comprobación falla, no continúes: descarga el instalador de nuevo. Si es correcta, instala Composer en /usr/local/bin:

sudo php composer-setup.php --install-dir=/usr/local/bin --filename=composer
rm composer-setup.php
composer --version

Composer version 2.8.x ...

Paso 6: Descargar Magento

Crea un usuario propietario de los archivos de Magento y añádelo al grupo www-data, con el que se ejecutan Nginx y PHP-FPM. Así el usuario controla el código y el servidor web puede escribir solo donde lo necesita:

sudo adduser --disabled-password --gecos "" magento
sudo usermod -aG www-data magento
sudo mkdir -p /var/www/magento
sudo chown magento:www-data /var/www/magento
sudo chmod 2775 /var/www/magento

El bit setgid (el 2 de 2775) hace que todo lo que se cree dentro herede el grupo www-data, necesario para que PHP-FPM pueda escribir en los directorios de ejecución.

Cambia al usuario magento y descarga Magento 2.4.8 con Composer. Cuando te pida usuario y contraseña para repo.magento.com, introduce la clave pública y la privada de Marketplace, y acepta guardarlas:

sudo -iu magento
composer create-project --repository-url=https://repo.magento.com/ magento/project-community-edition=2.4.8 /var/www/magento

La descarga tarda varios minutos. Después, ajusta los permisos que recomienda Adobe: los directorios en los que Magento escribe durante la ejecución deben ser modificables por el grupo:

cd /var/www/magento
find var generated vendor pub/static pub/media app/etc -type f -exec chmod g+w {} +
find var generated vendor pub/static pub/media app/etc -type d -exec chmod g+ws {} +
chmod u+x bin/magento

Comprueba que la CLI de Magento funciona:

bin/magento --version

Magento CLI 2.4.8

Paso 7: Instalar Magento

Ejecuta el instalador desde la línea de comandos, todavía como usuario magento. Sustituye los marcadores por tus valores; la contraseña del administrador debe tener al menos 7 caracteres, con letras y números:

bin/magento setup:install \
  --base-url=https://your_domain/ \
  --db-host=localhost \
  --db-name=magento \
  --db-user=magento \
  --db-password=your_strong_password \
  --admin-firstname=Admin \
  --admin-lastname=Tienda \
  --admin-email=admin@your_domain \
  --admin-user=your_admin_user \
  --admin-password=your_admin_password \
  --language=es_ES \
  --currency=EUR \
  --timezone=Europe/Madrid \
  --use-rewrites=1 \
  --search-engine=opensearch \
  --opensearch-host=127.0.0.1 \
  --opensearch-port=9200

Al terminar, el instalador muestra la ruta del panel de administración, que es aleatoria. Anótala:

[SUCCESS]: Magento installation complete.
[SUCCESS]: Magento Admin URI: /admin_1q2w3e

Paso 8: Configurar Nginx y HTTPS

Magento incluye una configuración de Nginx lista para usar en nginx.conf.sample, que sirve desde pub/ y bloquea el acceso a los directorios internos. Vuelve a tu usuario con sudo escribiendo exit y crea el bloque de servidor:

sudo nano /etc/nginx/sites-available/magento

upstream fastcgi_backend {
    server unix:/run/php/php8.3-fpm.sock;
}

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

    set $MAGE_ROOT /var/www/magento;
    include /var/www/magento/nginx.conf.sample;
}

Actívalo, desactiva el sitio por defecto y recarga Nginx:

sudo ln -s /etc/nginx/sites-available/magento /etc/nginx/sites-enabled/
sudo rm /etc/nginx/sites-enabled/default
sudo nginx -t
sudo systemctl reload nginx

Abre el cortafuegos y solicita el certificado con Certbot, que añadirá la configuración TLS y la redirección de HTTP a HTTPS:

sudo ufw allow OpenSSH
sudo ufw allow 'Nginx Full'
sudo ufw enable
sudo apt install -y certbot python3-certbot-nginx
sudo certbot --nginx -d your_domain

Comprueba que la tienda responde:

curl -sI https://your_domain/ | head -n 1

HTTP/2 200

Paso 9: Configurar la autenticación en dos pasos del administrador

Magento 2.4 obliga a usar autenticación en dos pasos para entrar al panel y, por defecto, envía el enlace de configuración por correo. Si tu servidor aún no envía correo, configura Google Authenticator (o cualquier app TOTP) desde la CLI. Como usuario magento, selecciona el proveedor TOTP:

sudo -iu magento
cd /var/www/magento
bin/magento config:set twofactorauth/general/force_providers google

Genera un secreto aleatorio en base32 y asígnalo a tu administrador:

SECRET="$(head -c 20 /dev/urandom | base32)"
echo "$SECRET"
bin/magento security:tfa:google:set-secret your_admin_user "$SECRET"

Añade el secreto que se muestra en pantalla a tu app de autenticación como clave manual (tipo basado en tiempo) y vuelve a tu usuario con sudo escribiendo exit. Ahora entra en https://your_domain/admin_1q2w3e con tu usuario y contraseña y el código de la app.

Paso 10: Usar Redis para caché y sesiones

Por defecto, Magento guarda la caché y las sesiones en archivos bajo var/, lo que se vuelve lento con tráfico. Con tu usuario con sudo, instala Redis:

sudo apt install -y redis-server
redis-cli ping

PONG

Configura Magento para usar tres bases de datos de Redis separadas: la 0 para la caché general, la 1 para la caché de página completa y la 2 para las sesiones. Cambia al usuario magento y ejecuta el resto de la guía con él:

sudo -iu magento
cd /var/www/magento
bin/magento setup:config:set --cache-backend=redis --cache-backend-redis-server=127.0.0.1 --cache-backend-redis-db=0
bin/magento setup:config:set --page-cache=redis --page-cache-redis-server=127.0.0.1 --page-cache-redis-db=1
bin/magento setup:config:set --session-save=redis --session-save-redis-host=127.0.0.1 --session-save-redis-db=2

Si te pregunta si quieres sobrescribir la configuración existente, responde Y. Vacía la caché, navega por la tienda y comprueba que aparecen claves en Redis:

bin/magento cache:flush
redis-cli info keyspace

# Keyspace
db0:keys=412,expires=0,avg_ttl=0
db1:keys=18,expires=18,avg_ttl=86251003
db2:keys=1,expires=1,avg_ttl=1199872

Paso 11: Activar el cron y los indexadores por programación

Magento depende del cron para reindexar, enviar correos, aplicar reglas de precios y limpiar datos. Instálalo en el crontab del usuario magento:

bin/magento cron:install
crontab -l

#~ MAGENTO START ...
* * * * * /usr/bin/php8.3 /var/www/magento/bin/magento cron:run 2>&1 | grep -v "Ran jobs by schedule" >> /var/www/magento/var/log/magento.cron.log
#~ MAGENTO END ...

Cambia los indexadores al modo Update by Schedule. En lugar de reindexar en cada cambio del panel, lo hacen en segundo plano con el cron, lo que agiliza la administración de catálogos grandes:

bin/magento indexer:set-mode schedule
bin/magento indexer:reindex
bin/magento indexer:status

Todos los indexadores deben aparecer como Ready y en modo Update by Schedule.

Paso 12: Pasar a modo producción

En modo producción, Magento compila la inyección de dependencias y genera todos los archivos estáticos por adelantado, en lugar de hacerlo en cada petición. Es el cambio que más mejora el rendimiento:

bin/magento deploy:mode:set production

El proceso tarda varios minutos. Genera también los estáticos para los idiomas que uses en la tienda y en el panel:

bin/magento setup:static-content:deploy es_ES en_US -f
bin/magento cache:flush
bin/magento deploy:mode:show

Current application mode: production. (Note: Environment variables may override this value.)

Desde ahora, cada vez que instales o actualices una extensión tendrás que ejecutar bin/magento setup:upgrade, bin/magento setup:di:compile y bin/magento setup:static-content:deploy es_ES en_US -f, en ese orden.

Paso 13: Comprobar el rendimiento

Mide el tiempo hasta el primer byte de la portada. La primera petición construye la caché de página; la segunda debe servirse desde Redis:

curl -o /dev/null -s -w 'TTFB: %{time_starttransfer}s\n' https://your_domain/
curl -o /dev/null -s -w 'TTFB: %{time_starttransfer}s\n' https://your_domain/

TTFB: 1.214s
TTFB: 0.182s

Confirma también en el panel, en Sistema > Gestión de caché, que todos los tipos de caché están activados.

Solución de problemas

Could not validate a connection to the OpenSearch durante la instalación. Comprueba que el contenedor está en marcha con sudo docker ps y revisa sus registros con sudo docker logs opensearch. Si se detiene por falta de memoria, amplía la RAM del servidor o reduce -Xms/-Xmx.

Errores de permisos en var/ o generated/. Algún comando se ejecutó como root o como otro usuario. Ejecuta bin/magento siempre como magento y restablece la propiedad con sudo chown -R magento:www-data /var/www/magento, seguido de los comandos find del paso 6.

La tienda se ve sin estilos tras un cambio. Faltan estáticos para algún idioma o tema. Repite bin/magento setup:static-content:deploy con los idiomas correspondientes y vacía la caché.

Allowed memory size exhausted al compilar. La CLI no está leyendo 99-magento.ini. Comprueba el enlace del paso 2 con php -i | grep memory_limit.

Conclusión

Tienes Magento 2.4.8 en producción sobre Ubuntu 24.04, con OpenSearch para el catálogo, Redis para caché y sesiones, indexación en segundo plano por cron y HTTPS. Como siguientes pasos, configura el envío de correo transaccional, programa copias de seguridad de la base de datos con mysqldump y del directorio pub/media, y valora añadir Varnish como caché de página completa si el tráfico crece, ya que es la opción que Adobe recomienda para tiendas grandes.