---
title: "Cómo instalar Let's Encrypt con Certbot en Ubuntu 24.04"
description: "Obtén certificados SSL/TLS gratuitos de Let's Encrypt con Certbot para Nginx o Apache en Ubuntu 24.04, activa HTTPS con redirección y automatiza la renovación."
category: "Servidores Web"
language: es
source: https://cubepath.com/es/docs/servidores-web/como-instalar-certificados-ssl-tls-con-lets-encrypt
updated: 2026-09-25
---

# Cómo instalar Let's Encrypt con Certbot en Ubuntu 24.04

Let's Encrypt es una autoridad de certificación gratuita y automatizada que emite certificados TLS válidos para cualquier navegador. Certbot es el cliente oficial recomendado por Let's Encrypt: valida que controlas el dominio mediante el protocolo ACME, descarga el certificado, configura el servidor web y lo renueva de forma automática. En este tutorial activarás HTTPS en un sitio servido por Nginx (o Apache) en Ubuntu 24.04, con redirección desde HTTP y renovación automática comprobada.

## Requisitos previos

Para seguir esta guía necesitas:

- Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath, y un usuario no root con privilegios `sudo`.
- Un nombre de dominio registrado. En esta guía se usa `your_domain` como marcador: sustitúyelo por tu dominio real en todos los comandos.
- Registros DNS de tipo A (y AAAA si usas IPv6) para `your_domain` y `www.your_domain` apuntando a la IP pública de tu servidor. Compruébalo con `dig +short your_domain`.
- Nginx instalado con un bloque `server` cuyo `server_name` sea `your_domain www.your_domain`, o Apache con un VirtualHost cuyo `ServerName` y `ServerAlias` coincidan.
- Los puertos 80 y 443 abiertos. Let's Encrypt valida el dominio conectándose al puerto 80, así que no puede estar bloqueado.

## Paso 1: Abrir los puertos HTTP y HTTPS en el firewall

Si usas UFW, permite el tráfico web completo. El perfil `Nginx Full` abre los puertos 80 y 443:

```bash
sudo ufw allow 'Nginx Full'
```

Si usas Apache, el perfil equivalente es `Apache Full`:

```bash
sudo ufw allow 'Apache Full'
```

Comprueba las reglas activas:

```bash
sudo ufw status
```

```output
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
Nginx Full                 ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
Nginx Full (v6)            ALLOW       Anywhere (v6)
```

Si antes tenías permitido solo `Nginx HTTP`, puedes eliminar esa regla redundante con `sudo ufw delete allow 'Nginx HTTP'`.

## Paso 2: Instalar Certbot

Ubuntu 24.04 incluye Certbot en sus repositorios, junto con los plugins que modifican automáticamente la configuración del servidor web. Instala Certbot y el plugin de tu servidor:

```bash
sudo apt update
sudo apt install certbot python3-certbot-nginx
```

Para Apache, instala en su lugar el plugin `python3-certbot-apache`:

```bash
sudo apt install certbot python3-certbot-apache
```

Comprueba que Certbot está disponible:

```bash
certbot --version
```

```output
certbot 2.9.0
```

> Nota: Let's Encrypt también distribuye Certbot como paquete snap, que se actualiza con más frecuencia. El paquete de Ubuntu es suficiente para todo lo que se ve en esta guía y se actualiza con `apt`. No instales ambos a la vez.

## Paso 3: Comprobar la configuración del servidor web

El plugin de Certbot localiza el bloque que debe modificar buscando el dominio en `server_name`. Revisa que tu sitio lo tenga definido:

```bash
grep -R "server_name" /etc/nginx/sites-enabled/
```

```output
/etc/nginx/sites-enabled/your_domain:    server_name your_domain www.your_domain;
```

Valida la sintaxis y recarga Nginx si has hecho cambios:

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

En Apache, la comprobación equivalente es:

```bash
sudo apache2ctl configtest
sudo apache2ctl -S
```

`apache2ctl -S` lista los VirtualHost con su `ServerName` y sus alias. Tu dominio debe aparecer en el puerto 80.

## Paso 4: Obtener el certificado

Ejecuta Certbot con el plugin de Nginx e indica cada nombre que debe incluir el certificado con `-d`:

```bash
sudo certbot --nginx -d your_domain -d www.your_domain
```

Para Apache, cambia el plugin:

```bash
sudo certbot --apache -d your_domain -d www.your_domain
```

La primera vez, Certbot te pide una dirección de correo para la cuenta ACME y que aceptes los términos de servicio. Después valida el dominio, instala el certificado en la configuración del sitio y añade la redirección de HTTP a HTTPS:

```output
Successfully received certificate.
Certificate is saved at: /etc/letsencrypt/live/your_domain/fullchain.pem
Key is saved at:         /etc/letsencrypt/live/your_domain/privkey.pem
This certificate expires on 2026-12-24.
These files will be updated when the certificate renews.
Certbot has set up a scheduled task to automatically renew this certificate in the background.

Deploying certificate
Successfully deployed certificate for your_domain to /etc/nginx/sites-enabled/your_domain
Successfully deployed certificate for www.your_domain to /etc/nginx/sites-enabled/your_domain
Congratulations! You have successfully enabled HTTPS on https://your_domain and https://www.your_domain
```

Certbot guarda los archivos en `/etc/letsencrypt/live/your_domain/`. Los que usa el servidor web son:

| Archivo | Contenido |
|---|---|
| `fullchain.pem` | Certificado del dominio más la cadena intermedia. Es el que se configura en Nginx y Apache. |
| `privkey.pem` | Clave privada. Solo la puede leer root. |
| `chain.pem` | Solo los certificados intermedios. |
| `cert.pem` | Solo el certificado del dominio. |

Estos archivos son enlaces simbólicos a la versión más reciente en `/etc/letsencrypt/archive/`, por eso la configuración del servidor no cambia al renovar.

> Consejo: si prefieres gestionar tú la configuración del servidor web y que Certbot solo obtenga el certificado, usa `sudo certbot certonly --nginx -d your_domain` y apunta tú mismo `ssl_certificate` y `ssl_certificate_key` a los archivos anteriores.

## Paso 5: Verificar HTTPS

Comprueba que el sitio responde por HTTPS con un certificado válido:

```bash
curl -I https://your_domain
```

```output
HTTP/1.1 200 OK
Server: nginx/1.24.0 (Ubuntu)
Content-Type: text/html
```

Comprueba también que las peticiones HTTP se redirigen:

```bash
curl -I http://your_domain
```

```output
HTTP/1.1 301 Moved Permanently
Server: nginx/1.24.0 (Ubuntu)
Location: https://your_domain/
```

Para ver el emisor y las fechas de validez del certificado que sirve el servidor:

```bash
echo | openssl s_client -connect your_domain:443 -servername your_domain 2>/dev/null | openssl x509 -noout -issuer -dates
```

```output
issuer=C = US, O = Let's Encrypt, CN = E7
notBefore=Sep 25 09:14:02 2026 GMT
notAfter=Dec 24 09:14:01 2026 GMT
```

El nombre del certificado intermedio (`E7`, `E8`, `R12`, etc.) varía según el tipo de clave y la fecha de emisión.

## Paso 6: Comprobar la renovación automática

Los certificados de Let's Encrypt caducan a los 90 días, y la autoridad está reduciendo ese plazo de forma progresiva, así que la renovación tiene que ser automática. El paquete de Ubuntu instala un temporizador de systemd, `certbot.timer`, que ejecuta `certbot renew` dos veces al día y solo renueva los certificados próximos a caducar:

```bash
systemctl list-timers certbot.timer
```

```output
NEXT                        LEFT     LAST PASSED UNIT          ACTIVATES
Fri 2026-09-25 21:48:00 UTC 9h left  -    -      certbot.timer certbot.service
```

Simula una renovación contra el entorno de pruebas de Let's Encrypt para confirmar que funcionará cuando llegue el momento:

```bash
sudo certbot renew --dry-run
```

```output
Processing /etc/letsencrypt/renewal/your_domain.conf
Account registered.
Simulating renewal of an existing certificate for your_domain and www.your_domain

Congratulations, all simulated renewals succeeded:
  /etc/letsencrypt/live/your_domain/fullchain.pem (success)
```

Con el plugin `--nginx` o `--apache`, Certbot recarga el servidor web tras renovar. Si obtuviste el certificado con `certonly` u otro método, añade un hook de despliegue para que el servidor cargue el certificado nuevo:

```bash
sudo nano /etc/letsencrypt/renewal-hooks/deploy/reload-nginx.sh
```

```bash
#!/usr/bin/env bash
set -euo pipefail
systemctl reload nginx
```

Hazlo ejecutable:

```bash
sudo chmod 755 /etc/letsencrypt/renewal-hooks/deploy/reload-nginx.sh
```

Certbot ejecuta los scripts de ese directorio solo cuando un certificado se renueva de verdad, no en cada comprobación.

> Nota: Let's Encrypt dejó de enviar correos de aviso de caducidad en 2025. No confíes en el correo: vigila la salida de `certbot renew` con `journalctl -u certbot.service` o con tu sistema de monitorización.

## Paso 7 (opcional): Obtener un certificado wildcard con validación DNS

Un certificado wildcard (`*.your_domain`) cubre todos los subdominios de primer nivel. Let's Encrypt solo lo emite mediante el desafío DNS-01, en el que Certbot crea un registro TXT en tu zona DNS. Con un plugin DNS esto se automatiza también en las renovaciones. Este ejemplo usa Cloudflare, cuyo plugin está en los repositorios de Ubuntu:

```bash
sudo apt install python3-certbot-dns-cloudflare
```

Crea en el panel de Cloudflare un token de API con permiso `Zone:DNS:Edit` limitado a tu zona y guárdalo en un archivo de credenciales:

```bash
sudo mkdir -p /root/.secrets
sudo nano /root/.secrets/cloudflare.ini
```

```ini
dns_cloudflare_api_token = your_cloudflare_api_token
```

Restringe los permisos, ya que Certbot rechaza credenciales legibles por otros usuarios con un aviso:

```bash
sudo chmod 600 /root/.secrets/cloudflare.ini
```

Solicita el certificado para el dominio raíz y el comodín:

```bash
sudo certbot certonly --dns-cloudflare \
  --dns-cloudflare-credentials /root/.secrets/cloudflare.ini \
  -d your_domain -d '*.your_domain'
```

El certificado queda en `/etc/letsencrypt/live/your_domain/`. Configúralo en Nginx y deja el hook de despliegue del paso anterior para que se recargue al renovar. Existen plugins equivalentes para otros proveedores DNS (por ejemplo `python3-certbot-dns-route53` o `python3-certbot-dns-digitalocean`).

## Gestionar certificados

Lista los certificados que gestiona Certbot, con sus dominios y fecha de caducidad:

```bash
sudo certbot certificates
```

```output
Found the following certs:
  Certificate Name: your_domain
    Serial Number: 4a1f...
    Key Type: ECDSA
    Domains: your_domain www.your_domain
    Expiry Date: 2026-12-24 09:14:01+00:00 (VALID: 89 days)
    Certificate Path: /etc/letsencrypt/live/your_domain/fullchain.pem
    Private Key Path: /etc/letsencrypt/live/your_domain/privkey.pem
```

Para añadir un nombre a un certificado existente, vuelve a ejecutar Certbot con `--cert-name` y la lista completa de dominios:

```bash
sudo certbot --nginx --cert-name your_domain -d your_domain -d www.your_domain -d blog.your_domain
```

Para eliminar un certificado que ya no usas (primero quita las referencias a él de la configuración del servidor web):

```bash
sudo certbot delete --cert-name your_domain
```

## Solución de problemas

- **`Timeout during connect (likely firewall problem)`**: Let's Encrypt no llega al puerto 80. Revisa UFW y cualquier firewall externo, y comprueba desde otra máquina con `curl -I http://your_domain`.
- **`DNS problem: NXDOMAIN looking up A for your_domain`**: el registro DNS no existe o no se ha propagado. Verifica con `dig +short your_domain @1.1.1.1` que devuelve la IP del servidor. Si tienes un registro AAAA, debe apuntar también a este servidor, porque Let's Encrypt prefiere IPv6.
- **`Could not automatically find a matching server block`**: ningún bloque de Nginx tiene ese dominio en `server_name`. Corrígelo, ejecuta `sudo nginx -t` y recarga.
- **`too many certificates already issued`**: has alcanzado un límite de emisión, por ejemplo el de 5 certificados idénticos por semana. Usa `--dry-run` o `--test-cert` para las pruebas y espera a que expire el límite.
- **`CAA record for your_domain prevents issuance`**: tu zona tiene registros CAA que no incluyen `letsencrypt.org`. Añade `your_domain. CAA 0 issue "letsencrypt.org"`.

## Conclusión

Has instalado Certbot, obtenido un certificado de Let's Encrypt para tu dominio, activado HTTPS con redirección desde HTTP y comprobado que la renovación automática funciona. A partir de aquí, el temporizador de systemd mantiene el certificado vigente sin intervención.

Como siguientes pasos puedes:

- Activar HTTP/2 en Nginx o Apache ahora que el sitio sirve HTTPS.
- Añadir la cabecera `Strict-Transport-Security` (HSTS) una vez confirmes que todos los subdominios funcionan con HTTPS.
- Analizar la configuración TLS con SSL Labs (ssllabs.com/ssltest) para detectar protocolos o cifrados débiles.