---
title: "Cómo instalar y optimizar Magento 2.4 en Ubuntu 24.04"
description: "Instala Magento Open Source 2.4.8 en Ubuntu 24.04 con Nginx, PHP 8.3, MySQL y OpenSearch, usa Redis para caché y sesiones y pasa la tienda a modo producción."
category: "E-commerce y CMS"
language: es
source: https://cubepath.com/es/docs/e-commerce-y-cms/instalacion-y-optimizacion-de-magento-2
updated: 2026-09-25
---

# Cómo instalar y optimizar Magento 2.4 en Ubuntu 24.04

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](https://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:

```bash
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:

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

```output
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:

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

```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:

```bash
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:

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

```output
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:

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

```ini
[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:

```bash
sudo systemctl restart mysql
```

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

```bash
sudo mysql
```

```sql
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:

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

```output
+--------------------+
| 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:

```bash
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:

```bash
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:

```bash
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
```

> Advertencia: no publiques nunca el puerto 9200 sin `127.0.0.1:` delante. Con la seguridad desactivada, cualquiera podría leer y borrar los índices.

Espera unos 30 segundos y comprueba que responde:

```bash
curl -s http://127.0.0.1:9200
```

```output
{
  "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:

```bash
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 -
```

```output
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`:

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

```output
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:

```bash
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:

```bash
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:

```bash
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:

```bash
bin/magento --version
```

```output
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:

```bash
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:

```output
[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:

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

```nginx
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:

```bash
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:

```bash
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:

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

```output
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:

```bash
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:

```bash
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:

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

```output
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:

```bash
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:

```bash
bin/magento cache:flush
redis-cli info keyspace
```

```output
# 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
```

> Importante: no configures en Redis una política de expulsión como `allkeys-lru`. Con las sesiones en la misma instancia, Redis podría borrar sesiones activas y cerrar los carritos de los clientes.

## 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`:

```bash
bin/magento cron:install
crontab -l
```

```output
#~ 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:

```bash
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:

```bash
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:

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

```output
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:

```bash
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/
```

```output
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.