---
title: "Cómo activar Gzip y Brotli en Nginx y Apache en Ubuntu 24.04"
description: "Activa la compresión Gzip y Brotli en Nginx y Apache en Ubuntu 24.04, elige qué tipos comprimir y comprueba con curl que las respuestas llegan comprimidas."
category: "Optimización de Rendimiento"
language: es
source: https://cubepath.com/es/docs/optimización-de-rendimiento/compresion-gzip-brotli-en-apache-y-nginx
updated: 2026-09-25
---

# Cómo activar Gzip y Brotli en Nginx y Apache en Ubuntu 24.04

Comprimir las respuestas de texto (HTML, CSS, JavaScript, JSON, SVG) reduce su tamaño entre un 60 % y un 90 %, con lo que las páginas cargan antes y se consume menos ancho de banda. Todos los navegadores actuales admiten Gzip y Brotli, y este último consigue ficheros algo más pequeños con un coste de CPU similar. En este tutorial activarás Gzip y Brotli en Nginx y en Apache sobre Ubuntu 24.04 y comprobarás con `curl` qué codificación sirve el servidor en cada caso. Sigue solo la parte del servidor web que uses.

## Requisitos previos

Para seguir esta guía necesitas:

- Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath.
- Un usuario no root con privilegios `sudo`.
- Nginx (`sudo apt install nginx`) o Apache (`sudo apt install apache2`) instalado y sirviendo una web.
- `curl` para las comprobaciones (viene instalado por defecto).

## Qué comprimir y qué no

La compresión solo tiene sentido para formatos de texto. Las imágenes JPEG, PNG y WebP, los vídeos, los ficheros ZIP y las fuentes WOFF2 ya están comprimidos, y volver a comprimirlos gasta CPU sin reducir su tamaño. Los tipos MIME que conviene comprimir son:

| Tipo de contenido | Tipos MIME |
|-------------------|------------|
| HTML | `text/html` |
| Hojas de estilo | `text/css` |
| JavaScript | `text/javascript`, `application/javascript` |
| Datos | `application/json`, `application/xml`, `text/xml`, `application/rss+xml` |
| Texto plano | `text/plain` |
| Gráficos vectoriales | `image/svg+xml` |

Tampoco merece la pena comprimir respuestas muy pequeñas: por debajo de unos cientos de bytes, la cabecera de compresión puede ocupar más de lo que se ahorra.

## Nginx

### Paso 1: Configurar Gzip

Nginx en Ubuntu trae el módulo gzip y lo activa en `/etc/nginx/nginx.conf` con `gzip on;`, pero con la configuración por defecto solo comprime `text/html`. Las demás opciones aparecen comentadas en ese fichero. En lugar de editarlo, crea un fichero propio en `conf.d`, que Nginx carga dentro del bloque `http`:

```bash
sudo nano /etc/nginx/conf.d/compression.conf
```

```nginx
# Gzip (gzip on ya está en nginx.conf)
gzip_vary on;
gzip_proxied any;
gzip_comp_level 5;
gzip_min_length 256;
gzip_types
    text/plain
    text/css
    text/xml
    text/javascript
    application/javascript
    application/json
    application/xml
    application/rss+xml
    image/svg+xml;
```

Qué hace cada directiva:

- `gzip_vary on`: añade la cabecera `Vary: Accept-Encoding` para que las cachés intermedias y las CDN guarden por separado la versión comprimida y la sin comprimir.
- `gzip_proxied any`: comprime también las respuestas a peticiones que llegan a través de un proxy o CDN.
- `gzip_comp_level 5`: nivel de 1 a 9. A partir de 5 o 6 la reducción de tamaño es mínima y el coste de CPU sigue subiendo.
- `gzip_min_length 256`: no comprime respuestas de menos de 256 bytes.
- `gzip_types`: tipos MIME a comprimir, además de `text/html`, que se comprime siempre.

No declares ninguna de estas directivas también en `nginx.conf` sin comentar, o Nginx dará un error de directiva duplicada.

Comprueba la configuración y recarga:

```bash
sudo nginx -t
sudo systemctl reload nginx
```

```output
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
```

### Paso 2: Instalar y configurar Brotli

Ubuntu 24.04 incluye el módulo de Brotli para Nginx en dos paquetes: `libnginx-mod-http-brotli-filter`, que comprime al vuelo, y `libnginx-mod-http-brotli-static`, que sirve ficheros `.br` precomprimidos. Instálalos:

```bash
sudo apt install libnginx-mod-http-brotli-filter libnginx-mod-http-brotli-static
```

Los paquetes cargan los módulos automáticamente mediante enlaces en `/etc/nginx/modules-enabled/`:

```bash
ls /etc/nginx/modules-enabled/
```

```output
50-mod-http-brotli-filter.conf
50-mod-http-brotli-static.conf
```

Añade la configuración de Brotli al mismo fichero `compression.conf`:

```bash
sudo nano /etc/nginx/conf.d/compression.conf
```

```nginx
# Brotli
brotli on;
brotli_comp_level 5;
brotli_min_length 256;
brotli_types
    text/plain
    text/css
    text/xml
    text/javascript
    application/javascript
    application/json
    application/xml
    application/rss+xml
    image/svg+xml;

# Servir ficheros precomprimidos .br y .gz si existen junto al original
brotli_static on;
gzip_static on;
```

Cuando el navegador acepta ambos formatos, Nginx sirve Brotli; los clientes que solo admiten Gzip siguen recibiendo Gzip. Con `brotli_static` y `gzip_static`, si existe `app.js.br` o `app.js.gz` junto a `app.js`, Nginx envía directamente el fichero precomprimido sin gastar CPU. Muchas herramientas de build de frontend pueden generar estos ficheros.

Comprueba y recarga:

```bash
sudo nginx -t
sudo systemctl reload nginx
```

## Apache

### Paso 1: Revisar Gzip (mod_deflate)

En Apache la compresión Gzip la hace `mod_deflate`, que en Ubuntu viene activado por defecto con una lista de tipos en `/etc/apache2/mods-available/deflate.conf`. Compruébalo:

```bash
apache2ctl -M | grep -E 'deflate|filter'
```

```output
 deflate_module (shared)
 filter_module (shared)
```

Si solo necesitas Gzip, ya lo tienes funcionando y puedes pasar a la sección de verificación.

### Paso 2: Activar Brotli (mod_brotli)

El módulo `mod_brotli` viene incluido en el paquete `apache2` de Ubuntu 24.04, pero desactivado. Actívalo:

```bash
sudo a2enmod brotli
```

Hay un detalle importante: si dejas la configuración de `deflate.conf` tal como está y añades Brotli por separado, Apache aplica primero Gzip y el navegador nunca recibe Brotli. La solución es declarar ambos filtros en una sola directiva, en el orden `BROTLI_COMPRESS;DEFLATE`: Brotli comprime si el cliente lo admite y, si no, lo hace Gzip.

Primero desactiva las líneas por defecto de `deflate.conf`:

```bash
sudo nano /etc/apache2/mods-available/deflate.conf
```

Comenta las líneas `AddOutputFilterByType` para que el fichero quede así:

```apache
<IfModule mod_filter.c>
	# AddOutputFilterByType DEFLATE text/html text/plain text/xml text/css text/javascript
	# AddOutputFilterByType DEFLATE application/x-javascript application/javascript application/ecmascript
	# AddOutputFilterByType DEFLATE application/rss+xml
	# AddOutputFilterByType DEFLATE application/wasm
	# AddOutputFilterByType DEFLATE application/xml
</IfModule>
```

Después crea un fichero de configuración propio con los dos filtros encadenados:

```bash
sudo nano /etc/apache2/conf-available/compression.conf
```

```apache
<IfModule mod_brotli.c>
    AddOutputFilterByType BROTLI_COMPRESS;DEFLATE text/html text/plain text/css text/xml text/javascript application/javascript application/json application/xml application/rss+xml image/svg+xml
    BrotliCompressionQuality 5
</IfModule>
```

`BrotliCompressionQuality` va de 0 a 11 y por defecto es 5, un buen equilibrio para compresión al vuelo. Los valores altos (10 u 11) son muy lentos y solo tienen sentido para ficheros precomprimidos.

Activa la configuración, comprueba la sintaxis y recarga Apache:

```bash
sudo a2enconf compression
sudo apache2ctl configtest
sudo systemctl reload apache2
```

```output
Syntax OK
```

## Verificar la compresión

La comprobación es la misma para Nginx y Apache. Pide una página indicando qué codificaciones acepta el cliente con la cabecera `Accept-Encoding` y mira la cabecera `Content-Encoding` de la respuesta. Sustituye `your_domain` por tu dominio o la IP del servidor.

Un cliente que acepta Gzip y Brotli, como cualquier navegador moderno, debe recibir Brotli:

```bash
curl -s -o /dev/null -D - -H 'Accept-Encoding: gzip, deflate, br' http://your_domain/ | grep -i -E 'content-encoding|vary'
```

```output
Vary: Accept-Encoding
Content-Encoding: br
```

Un cliente que solo acepta Gzip debe recibir Gzip:

```bash
curl -s -o /dev/null -D - -H 'Accept-Encoding: gzip' http://your_domain/ | grep -i -E 'content-encoding|vary'
```

```output
Vary: Accept-Encoding
Content-Encoding: gzip
```

Para ver el ahorro, compara los bytes descargados sin compresión y con Brotli:

```bash
curl -s -o /dev/null -w 'sin compresión: %{size_download} bytes\n' http://your_domain/
curl -s -o /dev/null -w 'brotli: %{size_download} bytes\n' -H 'Accept-Encoding: br' http://your_domain/
```

```output
sin compresión: 10671 bytes
brotli: 2722 bytes
```

Repite la prueba con un fichero CSS o JavaScript de tu web, por ejemplo `http://your_domain/assets/app.css`. También puedes comprobarlo en el navegador: en las herramientas de desarrollo, pestaña **Red**, la columna o cabecera `Content-Encoding` muestra `br` o `gzip` para cada recurso.

## Solución de problemas

- **No aparece `Content-Encoding`**: la respuesta es más pequeña que el mínimo configurado o su tipo MIME no está en la lista. Comprueba el tipo con `curl -sI http://your_domain/ruta | grep -i content-type`.
- **Apache sirve Gzip aunque el cliente acepta Brotli**: siguen activas las líneas `AddOutputFilterByType DEFLATE` de `deflate.conf` u otra directiva `DEFLATE` en tus virtual hosts o en un `.htaccess`. Elimínalas y deja solo la cadena `BROTLI_COMPRESS;DEFLATE`.
- **`unknown directive "brotli"` en Nginx**: el módulo no está cargado. Comprueba que los paquetes están instalados y que existen los enlaces en `/etc/nginx/modules-enabled/`.
- **Detrás de Cloudflare u otra CDN**: la CDN puede recomprimir o descomprimir las respuestas hacia el visitante. Comprueba las cabeceras directamente contra la IP del servidor para aislar el comportamiento de tu origen.
- **Uso de CPU alto**: baja `gzip_comp_level`, `brotli_comp_level` o `BrotliCompressionQuality`, y sirve ficheros estáticos precomprimidos cuando sea posible.

## Conclusión

Tu servidor web comprime ahora las respuestas de texto con Brotli para los navegadores que lo admiten y con Gzip para el resto, y sabes comprobarlo con `curl`. Como siguientes pasos, configura cabeceras de caché del navegador para los ficheros estáticos, activa HTTP/2 junto con HTTPS y mide el efecto de cada cambio con Apache Bench o con las herramientas de desarrollo del navegador.