Entorno de trabajo para Apache en Linux

Definir el sistema base (Debian/Ubuntu vs RHEL/Rocky)

Antes de tocar Apache, conviene identificar con precisión la familia de tu distribución porque cambian rutas, nombres de paquetes, servicios y herramientas de administración. En este capítulo trabajaremos con dos familias comunes:

• Debian/Ubuntu: usa apt, suele llamar al servicio apache2 y organiza la configuración en /etc/apache2.
• RHEL/CentOS/Rocky: usa dnf (o yum en sistemas antiguos), suele llamar al servicio httpd y organiza la configuración en /etc/httpd.

Comprobar distribución, versión y gestor de paquetes

Ejecuta estos comandos para saber exactamente dónde estás:

cat /etc/os-release
uname -r
command -v apt || true
command -v dnf || command -v yum || true

También es útil confirmar si el sistema usa systemd (lo normal hoy):

ps -p 1 -o comm=

Preparar el entorno para administrar Apache con seguridad

Administrar con seguridad significa: usar acceso remoto controlado (SSH), aplicar el principio de mínimo privilegio (usar sudo en vez de root directo cuando sea posible), y tener herramientas para diagnosticar red/DNS y revisar logs sin improvisar.

1) Acceso y privilegios (SSH/local y sudo)

Verifica cómo estás conectado y si tienes permisos administrativos:

Continúa en nuestra aplicación.

• Escuche el audio con la pantalla apagada.
• Obtenga un certificado al finalizar.
• ¡Más de 5000 cursos para que explores!

O continúa leyendo más abajo...

Descargar la aplicación

whoami
id
sudo -n true 2>/dev/null && echo "sudo OK" || echo "sudo requiere contraseña o no está permitido"

Si vas por SSH, confirma sesión y origen:

echo $SSH_CONNECTION
last -a | head

Buenas prácticas rápidas:

• Evita trabajar como root de forma permanente; usa sudo para acciones puntuales.
• Si vas a editar configuración, usa una sesión con tmux o screen para evitar cortes (opcional pero recomendable).

2) Instalar herramientas esenciales

Estas herramientas cubren edición, descargas HTTP, diagnóstico de red, DNS y revisión de puertos. Instala según tu familia.

Debian/Ubuntu (apt)

sudo apt update
sudo apt install -y vim nano curl wget ca-certificates \
  net-tools iproute2 dnsutils \
  traceroute tcpdump \
  lsof \
  openssh-client

RHEL/CentOS/Rocky (dnf)

sudo dnf -y install vim-enhanced nano curl wget ca-certificates \
  net-tools iproute bind-utils \
  traceroute tcpdump \
  lsof \
  openssh-clients

Notas útiles:

• DNS: dnsutils (Debian/Ubuntu) equivale a bind-utils (RHEL/Rocky) para tener dig y nslookup.
• Puertos: ss viene con iproute2 y suele ser preferible a netstat.

3) Verificación de conectividad (red y salida a Internet)

Antes de instalar o actualizar paquetes, confirma que el servidor tiene conectividad y rutas correctas.

Comprobar IP, gateway y rutas

ip a
ip r

Probar conectividad básica

ping -c 2 1.1.1.1
ping -c 2 8.8.8.8

Si el ping está bloqueado por políticas, prueba salida TCP/HTTPS con curl:

curl -I https://example.com

4) Verificación de DNS y resolución local

Apache depende de DNS en varios escenarios (virtual hosts por nombre, validaciones TLS, integraciones, repositorios). Asegura que el sistema resuelve nombres correctamente y que tu hostname está bien definido.

Comprobar resolvers y estado de systemd-resolved

cat /etc/resolv.conf
( command -v resolvectl && resolvectl status ) || true

Probar resolución DNS

getent hosts example.com
( command -v dig && dig +short example.com ) || true

Revisar hostname y resolución local (hosts)

hostnamectl
cat /etc/hosts

Ejemplo típico de entrada útil en /etc/hosts (ajusta IP/hostname):

127.0.0.1   localhost
192.0.2.10  web01.midominio.local web01

Si tu servidor debe resolver un nombre interno (por ejemplo, web01.midominio.local) y no existe DNS corporativo para ello, /etc/hosts es una solución local rápida. Recuerda que no escala para muchos servidores.

Estructura de directorios relevante para Apache

Para administrar Apache con confianza, necesitas ubicar tres cosas: document root (contenido), configuración (archivos que definen el servicio) y logs (diagnóstico). Las rutas cambian según la distribución, y además pueden estar personalizadas.

Rutas típicas por familia

Cómo identificar rutas reales en tu servidor

Incluso si conoces las rutas típicas, confirma la configuración efectiva. Estos comandos te ayudan a descubrirla sin adivinar.

1) Localizar el binario y el servicio

command -v apache2 || command -v httpd
systemctl list-unit-files | grep -E 'apache2|httpd' || true

2) Ver rutas de configuración y parámetros compilados

En Debian/Ubuntu:

apache2 -V

En RHEL/Rocky:

httpd -V

Busca en la salida valores como SERVER_CONFIG_FILE y HTTPD_ROOT.

3) Encontrar el DocumentRoot y los VirtualHosts

Una forma práctica es buscar directivas clave:

sudo grep -R "^DocumentRoot" -n /etc/apache2 2>/dev/null || true
sudo grep -R "^DocumentRoot" -n /etc/httpd 2>/dev/null || true

Para localizar definiciones de VirtualHost (útil para saber qué archivos se cargan):

sudo grep -R "<VirtualHost" -n /etc/apache2 2>/dev/null || true
sudo grep -R "<VirtualHost" -n /etc/httpd 2>/dev/null || true

4) Identificar logs activos

Los logs se definen con ErrorLog y CustomLog. Localízalos así:

sudo grep -R "^ErrorLog" -n /etc/apache2 2>/dev/null || true
sudo grep -R "^CustomLog" -n /etc/apache2 2>/dev/null || true
sudo grep -R "^ErrorLog" -n /etc/httpd 2>/dev/null || true
sudo grep -R "^CustomLog" -n /etc/httpd 2>/dev/null || true

Y revisa en tiempo real (ajusta la ruta):

sudo tail -f /var/log/apache2/error.log
sudo tail -f /var/log/httpd/error_log

Comprobaciones operativas antes de administrar Apache

Esta lista te ayuda a confirmar que el entorno está listo para instalar, configurar y levantar Apache sin sorpresas.

Lista de comprobación (checklist)

• Acceso por SSH/local: puedes entrar al servidor y mantener la sesión estable (idealmente con claves SSH y sin depender de una sola terminal).
• Permisos de administrador: sudo funciona para instalar paquetes, editar /etc y gestionar servicios.
• Puertos disponibles: no hay conflictos en 80/443 (u otros que planees usar).
• Firewall activo y reglas claras: sabes si está activo y qué puertos permite; puedes abrir/cerrar puertos de forma controlada.

Comprobar puertos en uso (80/443)

sudo ss -ltnp | grep -E ':(80|443)\b' || echo "80/443 libres (o sin permisos para ver procesos)"
sudo lsof -iTCP -sTCP:LISTEN -P -n | grep -E ':(80|443)\b' || true

Comprobar firewall (según distribución)

En RHEL/Rocky suele usarse firewalld:

sudo systemctl is-active firewalld && sudo firewall-cmd --list-all || echo "firewalld no activo"
sudo firewall-cmd --get-active-zones 2>/dev/null || true

En Debian/Ubuntu es común ufw (si está instalado):

command -v ufw && sudo ufw status verbose || echo "ufw no instalado o no disponible"

Si necesitas una verificación rápida de filtrado a nivel kernel:

sudo nft list ruleset 2>/dev/null | head || true
sudo iptables -S 2>/dev/null | head || true