Servidor web seguro en casa y en Internet con LMDE 7: Apache + HTTPS local y público paso a paso

Hoy vamos a montar algo muy interesante (y muy realista si tienes una pequeña empresa, Academia, o simplemente quieres jugar con infra en casa): un servidor web con Apache en LMDE 7 que sirva dos webs distintas:

Una web interna tipo “intranet” solo para tu red local, con HTTPS propio firmado por tu propia Autoridad Certificadora (CA).
Una web pública en Internet con HTTPS válido oficial (Let’s Encrypt).

Y todo esto en la misma máquina 👇

Sistema usado: LMDE 7 (Linux Mint Debian Edition)
Servidor web: Apache
Dominios de ejemplo:
- intranet.local → solo en tu LAN
- midominio.com → público en Internet

Tabla de contenidos

Índice rápido

Requisitos previos
Instalar y arrancar Apache en LMDE 7
Crear dos sitios web (VirtualHosts): interno y público
Activar HTTPS en la intranet con tu propio certificado local
Activar HTTPS público con Let’s Encrypt
¿Se pueden tener los dos a la vez en el mismo servidor?
Notas de firewall / router
Conclusión y siguiente paso

1. Requisitos previos

Antes de empezar, asegúrate de tener:

Una máquina con LMDE 7 encendida y con acceso a Internet.
Acceso root o sudo.
Un dominio público que puedas apuntar a tu IP (ej: midominio.com) para la parte externa.
Un nombre interno que usarás en tu red local (ej: intranet.local). Ese nombre lo resolverás tú mismo en tu DNS interno o con /etc/hosts en los PCs de la red.

2. Instalar y arrancar Apache en LMDE 7

Actualizamos el sistema e instalamos Apache:

sudo apt update && sudo apt upgrade -y
sudo apt install -y apache2

Arrancamos y activamos el servicio:

sudo systemctl enable apache2
sudo systemctl start apache2
sudo systemctl status apache2

Si todo va bien, status te mostrará algo como active (running).

Prueba en el navegador:

Desde el propio servidor: http://localhost
Desde otro PC de tu red: http://IP_DEL_SERVIDOR
Ejemplo: http://192.168.1.50

Tendrás la clásica página de “It works!” de Apache.

3. Crear dos sitios web (VirtualHosts): interno y público

En Debian/Mint, Apache separa los sitios en:

/etc/apache2/sites-available/ → donde creas/guardas config
/etc/apache2/sites-enabled/ → lo que está activo

Vamos a crear las carpetas web de cada sitio:

# sitio interno (solo LAN)
sudo mkdir -p /var/www/intranet.local/public_html

# sitio público (internet)
sudo mkdir -p /var/www/midominio.com/public_html

Metemos una página mínima en cada uno:

echo "<h1>Hola LAN segura</h1>" | sudo tee /var/www/intranet.local/public_html/index.html
echo "<h1>Hola Internet segura</h1>" | sudo tee /var/www/midominio.com/public_html/index.html

3.1. VirtualHost HTTP de la intranet (puerto 80)

Creamos /etc/apache2/sites-available/intranet.local.conf:

<VirtualHost *:80>
    ServerName intranet.local
    ServerAdmin admin@intranet.local

    DocumentRoot /var/www/intranet.local/public_html
    DirectoryIndex index.html index.php

    ErrorLog ${APACHE_LOG_DIR}/intranet_error.log
    CustomLog ${APACHE_LOG_DIR}/intranet_access.log combined

    <Directory /var/www/intranet.local/public_html>
        Options Indexes FollowSymLinks
        AllowOverride All
        Require all granted
    </Directory>
</VirtualHost>

3.2. VirtualHost HTTP público (puerto 80)

Creamos /etc/apache2/sites-available/midominio.com.conf:

<VirtualHost *:80>
    ServerName midominio.com
    ServerAdmin admin@midominio.com

    DocumentRoot /var/www/midominio.com/public_html
    DirectoryIndex index.html index.php

    ErrorLog ${APACHE_LOG_DIR}/public_error.log
    CustomLog ${APACHE_LOG_DIR}/public_access.log combined

    <Directory /var/www/midominio.com/public_html>
        Options Indexes FollowSymLinks
        AllowOverride All
        Require all granted
    </Directory>
</VirtualHost>

3.3. Habilitar nuestros sitios y deshabilitar el default

sudo a2dissite 000-default.conf
sudo a2ensite intranet.local.conf
sudo a2ensite midominio.com.conf
sudo systemctl reload apache2

Hasta aquí, los dos sitios funcionan en HTTP normal (sin cifrar).
Ahora viene lo bueno: HTTPS interno y HTTPS público.

4. HTTPS en la intranet con tu propio certificado (CA local)

Esta parte resuelve la típica pregunta:

“¿Cómo consigo HTTPS en mi red local aunque no tenga dominio público ni quiero pagar nada?”

Respuesta: creamos nuestra propia Autoridad Certificadora (CA), firmamos el certificado del servidor interno con esa CA y luego instalamos la CA en los PCs de la red para que el candado salga en verde sin aviso.

4.1. Crear tu CA local

mkdir ~/ca-local && cd ~/ca-local

# Clave privada de la CA
openssl genrsa -out ca-local.key 4096

# Certificado raíz de la CA (válido ~5 años)
openssl req -x509 -new -nodes \
  -key ca-local.key \
  -sha256 -days 1825 \
  -out ca-local.crt \
  -subj "/C=ES/ST=Cadiz/L=TuCiudad/O=TuEmpresa/OU=IT/CN=CA-LAN"

Lo importante:

ca-local.key → clave privada de TU CA (guárdala bien).
ca-local.crt → certificado raíz que luego instalas en los clientes para que confíen.

4.2. Crear clave y CSR para tu intranet

cd ~/ca-local

# Clave privada del servidor interno (intranet.local)
openssl genrsa -out intranet.local.key 4096

# Petición de certificado (CSR)
openssl req -new -key intranet.local.key -out intranet.local.csr \
  -subj "/C=ES/ST=Cadiz/L=TuCiudad/O=TuEmpresa/OU=IT/CN=intranet.local"

Ahora definimos las extensiones SAN (Subject Alternative Name).
Crea el archivo intranet.local.ext:

cat > intranet.local.ext << 'EOF'
authorityKeyIdentifier=keyid,issuer
basicConstraints=CA:FALSE
keyUsage = digitalSignature, keyEncipherment
extendedKeyUsage = serverAuth
subjectAltName = @alt_names

[alt_names]

DNS.1 = intranet.local IP.1 = 192.168.1.50 EOF

Cambia 192.168.1.50 por la IP real de tu servidor en la LAN.

Firmamos el CSR con nuestra CA:

openssl x509 -req -in intranet.local.csr \
  -CA ca-local.crt -CAkey ca-local.key -CAcreateserial \
  -out intranet.local.crt -days 825 -sha256 \
  -extfile intranet.local.ext

Ahora tienes:

intranet.local.crt → certificado del servidor
intranet.local.key → clave privada del servidor
ca-local.crt → CA raíz que tendrás que instalar en los clientes

4.3. Instalar el certificado en Apache

Creamos una carpeta para guardarlos en el servidor:

sudo mkdir -p /etc/ssl/intranet.local
sudo cp intranet.local.key /etc/ssl/intranet.local/
sudo cp intranet.local.crt /etc/ssl/intranet.local/
sudo chmod 600 /etc/ssl/intranet.local/intranet.local.key

Activamos el módulo SSL de Apache (si no está ya):

sudo a2enmod ssl

Creamos el VirtualHost HTTPS (puerto 443) interno:

sudo nano /etc/apache2/sites-available/intranet.local-ssl.conf

Contenido:

<VirtualHost *:443>
    ServerName intranet.local
    ServerAdmin admin@intranet.local

    DocumentRoot /var/www/intranet.local/public_html
    DirectoryIndex index.html index.php

    ErrorLog ${APACHE_LOG_DIR}/intranet_ssl_error.log
    CustomLog ${APACHE_LOG_DIR}/intranet_ssl_access.log combined

    SSLEngine on
    SSLCertificateFile    /etc/ssl/intranet.local/intranet.local.crt
    SSLCertificateKeyFile /etc/ssl/intranet.local/intranet.local.key

    <Directory /var/www/intranet.local/public_html>
        Options Indexes FollowSymLinks
        AllowOverride All
        Require all granted
    </Directory>
</VirtualHost>

Activamos el sitio HTTPS y recargamos Apache:

sudo a2ensite intranet.local-ssl.conf
sudo systemctl reload apache2

4.4. Evitar el aviso de “sitio no seguro” en los clientes de la red

En cada PC cliente tienes que confiar en tu CA (ca-local.crt):

En Windows:
1. Ejecuta certmgr.msc
2. Ve a “Entidades emisoras raíz de confianza” (Root CAs)
3. Importa ca-local.crt
En Linux:
1. Copia ca-local.crt a /usr/local/share/ca-certificates/
2. Ejecuta sudo update-ca-certificates

Después, desde otro equipo en tu red:

Abre https://intranet.local
o https://192.168.1.50 (si esa IP está en el SAN)

Deberías ver candado verde sin advertencia.
Tu intranet ya viaja cifrada (TLS), aunque no uses una CA pública.

5. HTTPS público con Let’s Encrypt

Ahora vamos con la parte “para web pública” en el mismo servidor.

Aquí sí queremos un certificado TLS reconocido mundialmente, gratis y renovable. Eso lo da Let’s Encrypt usando certbot.

5.1. Requisitos

Tu dominio (midominio.com) apunta por DNS a tu IP pública.
Tu router reenvía (port forwarding / NAT) los puertos 80 (HTTP) y 443 (HTTPS) hasta tu servidor LMDE 7.
Apache ya está sirviendo midominio.com en HTTP (paso 3.2).

5.2. Instalar certbot y el plugin de Apache

sudo apt install -y certbot python3-certbot-apache

5.3. Emitir el certificado y configurar Apache automáticamente

sudo certbot --apache --agree-tos --redirect \
  -d midominio.com \
  -m admin@midominio.com

Este comando hace varias cosas por ti:

Comprueba que realmente controlas midominio.com.
Obtiene un certificado TLS válido.
Crea (o modifica) el VirtualHost en puerto 443 con SSLCertificateFile y SSLCertificateKeyFile.
Activa redirección automática HTTP → HTTPS (--redirect).
Configura la renovación automática.

Cuando termine, abre tu navegador (desde fuera, desde el móvil con datos, etc.) y entra a:

https://midominio.com

Verás candado verde sin trucos raros ni advertencias.

6. ¿Puedo tener la intranet HTTPS y la web pública HTTPS a la vez?

Sí, y de hecho esa es la gracia de este tutorial.

En Apache puedes tener varios <VirtualHost *:443> diferentes, uno por nombre. Cada uno usa su propio ServerName y su propio par de certificado/clave.

Ejemplo típico final en /etc/apache2/sites-enabled/:

intranet.local.conf (HTTP interno 80)
intranet.local-ssl.conf (HTTPS interno 443 con tu CA)
midominio.com.conf (HTTP público 80)
midominio.com-le-ssl.conf (HTTPS público 443 con Let’s Encrypt; este archivo lo crea certbot)

Apache elegirá el certificado correcto usando SNI (Server Name Indication): cuando el navegador pide intranet.local, le sirve tu certificado interno; cuando pide midominio.com, le sirve el de Let’s Encrypt.

Todo en una única máquina LMDE 7.

7. Notas de firewall y router

En el servidor Linux puedes usar ufw para abrir solo lo que necesitas:

sudo apt install -y ufw
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable
sudo ufw status

En tu router:
- Redirige los puertos 80 y 443 hacia la IP del servidor solo si quieres que la web pública sea accesible desde Internet.
- Para la intranet (intranet.local) puedes dejarla totalmente privada: ese nombre ni siquiera tiene que existir en Internet. Basta con que exista en tu DNS interno o en tu /etc/hosts.

8. Conclusión y siguiente paso

Lo que hemos conseguido:

Servidor Apache en LMDE 7 funcionando.
Dos sitios diferentes en la misma máquina:
- Uno interno (intranet.local)
- Uno público (midominio.com)
HTTPS interno con una CA propia.
- Tráfico cifrado dentro de tu red local.
- Candado verde cuando instalas tu CA en los clientes.
HTTPS público automático con Let’s Encrypt.
- Certificado reconocido globalmente.
- Renovación automática.

Esto es exactamente el escenario que mucha gente pregunta:

“Quiero usar el mismo servidor para mi intranet privada y mi web pública, y quiero SSL/TLS en los dos sitios. ¿Se puede?”
Sí. Se puede. Lo acabas de ver.

¿Qué puedes hacer ahora?

Añadir autenticación (por ejemplo .htpasswd) a la intranet para que solo entren tus alumnos/empleados.
Montar una pequeña wiki interna, un panel de control, o un Nextcloud interno en intranet.local.
Grabar este proceso en vídeo (pantalla + cámara) y usarlo como contenido técnico de mucho valor, porque esto es 100

Listo para publicar 💻🔒