Cómo Configurar el Nombre de Host y FQDN Correctamente

Configurar correctamente el nombre de host de tu servidor y el Nombre de Dominio Completamente Cualificado (FQDN) es esencial para la identificación del servidor, comunicación de red, entrega de correo, certificados SSL y varias operaciones del sistema. Esta guía completa explica cómo configurar correctamente nombres de host y FQDNs en servidores Linux en diferentes distribuciones, asegurando la resolución DNS apropiada y la configuración del sistema.

Tabla de Contenidos

Prerrequisitos

Antes de configurar el nombre de host y FQDN, asegúrate de tener:

  • Servidor Linux (Ubuntu, Debian, CentOS, Rocky Linux o similar)
  • Acceso root o privilegios sudo
  • Acceso SSH o consola al servidor
  • Nombre de dominio (para configuración FQDN)
  • Acceso a gestión DNS (si configuras registros DNS)
  • Comprensión básica de conceptos DNS y de redes
  • Comprensión del propósito previsto de tu servidor

Comprendiendo Nombres de Host y FQDNs

¿Qué es un Nombre de Host?

Un nombre de host es una etiqueta legible por humanos que identifica una computadora en una red. Se usa para identificación local y debe ser único dentro de su segmento de red.

Ejemplos de nombres de host:

  • web01
  • database-server
  • mail
  • app-prod-01

Características del nombre de host:

  • Máximo 63 caracteres
  • Puede contener letras (a-z, A-Z), números (0-9) y guiones (-)
  • No puede comenzar o terminar con guión
  • Insensible a mayúsculas (tratado como minúsculas)
  • Debe ser descriptivo y seguir convenciones de nomenclatura

¿Qué es un FQDN?

Un Nombre de Dominio Completamente Cualificado (FQDN) es el nombre de dominio completo para una computadora u host específico en internet. Consiste en el nombre de host más el nombre de dominio.

Formato FQDN:

nombre-host.dominio.tld

Ejemplos de FQDN:

  • web01.example.com
  • mail.company.org
  • db.internal.network.local
  • server1.us-east.example.net

Componentes del FQDN:

  • Nombre de host: web01
  • Dominio: example.com
  • FQDN: web01.example.com

Tipos de Nombres de Host en Linux

Los sistemas Linux mantienen tres tipos de nombres de host:

  1. Nombre de host estático: Nombre de host persistente almacenado en /etc/hostname
  2. Nombre de host transitorio: Nombre de host dinámico mantenido por el kernel
  3. Nombre de host bonito: Nombre de host UTF-8 de forma libre para presentación

Por Qué Importa la Configuración Apropiada

La configuración correcta de nombre de host/FQDN es crítica para:

  • Servidores de correo: La entrega de correo depende del FQDN apropiado
  • Certificados SSL/TLS: Deben coincidir con el FQDN
  • Autenticación Kerberos: Requiere FQDN correcto
  • Clustering y HA: Identificación de nodos
  • Registro y monitoreo: Atribución apropiada de registros
  • Resolución DNS: Búsquedas DNS inversas
  • Funcionalidad de aplicación: Muchas aplicaciones verifican el nombre de host
  • Administración del sistema: Identificación clara del servidor

Consecuencias de la mala configuración:

  • Los correos rebotan o van a spam
  • Fallos de validación de certificados
  • Errores de aplicación
  • Inconsistencias de registro
  • Fallos de autenticación
  • Mala visibilidad de solución de problemas

Paso 1: Verificar la Configuración Actual del Nombre de Host

Antes de hacer cambios, examina tu configuración actual.

Ver Nombre de Host Actual

# Mostrar nombre de host actual
hostname

# Mostrar nombre de host corto
hostname -s

# Mostrar FQDN
hostname -f

# Mostrar nombre de dominio
hostname -d

# Mostrar todos los tipos de nombre de host
hostname -A

# Mostrar dirección IP asociada con nombre de host
hostname -I
hostname -i

Usando hostnamectl (sistemas systemd)

# Mostrar toda la información del nombre de host
hostnamectl

# Mostrar solo nombre de host estático
hostnamectl --static

# Mostrar nombre de host transitorio
hostnamectl --transient

# Mostrar nombre de host bonito
hostnamectl --pretty

Ejemplo de salida esperada:

   Static hostname: web01
   Pretty hostname: Servidor Web 01
         Icon name: computer-vm
           Chassis: vm
        Machine ID: a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6
           Boot ID: x1y2z3a4b5c6d7e8f9g0h1i2j3k4l5m6
    Virtualization: kvm
  Operating System: Rocky Linux 9.1
       CPE OS Name: cpe:/o:rocky:rocky:9::baseos
            Kernel: Linux 5.14.0-162.6.1.el9_1.x86_64
      Architecture: x86-64

Verificar Archivo /etc/hostname

# Mostrar contenidos del archivo hostname
cat /etc/hostname

# Ubuntu/Debian también almacena en:
cat /etc/debian_hostname  # Si existe

Verificar Archivo /etc/hosts

# Mostrar archivo hosts
cat /etc/hosts

# Buscar entradas de nombre de host
grep $(hostname) /etc/hosts

Verificar Resolución DNS

# Probar resolución de nombre de host
nslookup $(hostname)
dig $(hostname)
host $(hostname)

# Probar DNS inverso
dig -x $(hostname -I | awk '{print $1}')

# Verificar configuración del resolver
cat /etc/resolv.conf

Información del Sistema

# Mostrar identificación del sistema
cat /etc/os-release

# ID de máquina
cat /etc/machine-id

# Configuración de red
ip addr show
nmcli device show

Paso 2: Elegir Nombres de Host Apropiados

Convenciones de Nomenclatura de Nombres de Host

Mejores prácticas para elegir nombres de host:

  1. Descriptivo pero conciso: Indicar propósito y ubicación
  2. Esquema consistente: Seguir estándares organizacionales
  3. Evitar nombres personales: Usar descriptores funcionales
  4. Incluir indicadores de entorno: dev, staging, prod
  5. Numeración secuencial: Para servidores similares
  6. Códigos de ubicación: Identificadores geográficos o de centro de datos

Buenos ejemplos de nombres de host:

# Servidores web
web01-prod-us-east
web-frontend-01
www-eu-west

# Servidores de base de datos
db-mysql-01-prod
postgres-primary-nyc
mongo-shard01

# Servidores de aplicación
app-nodejs-staging
api-gateway-prod
worker-queue-01

# Servidores de correo
mail-inbound-01
smtp-relay-us
mx1

# Servidores DNS
ns1
dns-primary-dc1

# Servidores de monitoreo
monitor-prometheus
grafana-prod
log-collector-01

Patrones de nombres de host:

# Patrón: servicio-propósito-número-entorno-ubicación
web-frontend-01-prod-us-east
db-mysql-02-staging-eu-west
app-api-03-dev-local

# Patrón: rol-número.datacenter.entorno
web01.nyc.prod
db02.lax.staging
app03.local.dev

Consideraciones del FQDN

Mejores prácticas del FQDN:

  1. Coincidir con uso previsto: El servidor web debe tener prefijo www o web
  2. Organización de subdominio: Usar subdominios para segregación de servicios
  3. Distribución geográfica: Incluir ubicación en subdominio
  4. Separación de entorno: Diferentes dominios o subdominios por entorno
  5. Certificados comodín: Planificar para cobertura SSL

Ejemplos de FQDN:

# Servidores web de producción
www.example.com
web01.example.com
frontend.example.com

# Servidores API
api.example.com
api-v2.example.com
gateway.api.example.com

# Servicios internos
db.internal.example.com
cache.internal.example.com
queue.internal.example.com

# Servidores de correo
mail.example.com
smtp.example.com
mx1.mail.example.com

# Servidores regionales
www.us-east.example.com
db.eu-west.example.com
api.asia.example.com

# Específicos de entorno
dev.example.com
staging.example.com
prod.example.com

# Subdominios específicos de servicio
jenkins.ci.example.com
grafana.monitoring.example.com
gitlab.git.example.com

Requisitos y Restricciones del Nombre de Host

Caracteres válidos:

  • Letras minúsculas: a-z
  • Letras mayúsculas: A-Z (convertidas a minúsculas)
  • Números: 0-9
  • Guiones: - (no al principio o final)

Caracteres inválidos:

  • Guiones bajos: _ (no recomendado, aunque técnicamente permitido en DNS)
  • Espacios y caracteres especiales
  • Puntos: . (reservados para separación de dominio)

Límites de longitud:

  • Nombre de host: Máximo 63 caracteres
  • FQDN: Máximo 253 caracteres en total
  • Cada etiqueta (entre puntos): Máximo 63 caracteres

Paso 3: Establecer Nombre de Host en Ubuntu/Debian

Usando hostnamectl (Recomendado)

# Establecer nombre de host estático
sudo hostnamectl set-hostname web01

# Establecer nombre de host FQDN
sudo hostnamectl set-hostname web01.example.com

# Establecer nombre de host bonito
sudo hostnamectl set-hostname "Servidor Web 01" --pretty

# Establecer nombre de host transitorio (temporal)
sudo hostnamectl set-hostname temp-name --transient

# Establecer todo a la vez
sudo hostnamectl set-hostname web01.example.com
sudo hostnamectl set-hostname "Servidor Web 01" --pretty

Verificar cambios:

# Verificar nuevo nombre de host
hostnamectl

# Verificar comando hostname
hostname
hostname -f

Usando Comando hostname (Método Legacy)

# Establecer nombre de host transitorio (se pierde al reiniciar)
sudo hostname web01

# Hacer permanente editando archivo
echo "web01.example.com" | sudo tee /etc/hostname

# Actualizar archivo hosts
sudo nano /etc/hostname

Editando /etc/hostname Directamente

# Respaldar archivo de nombre de host actual
sudo cp /etc/hostname /etc/hostname.backup

# Editar archivo hostname
sudo nano /etc/hostname

Cambiar a:

web01.example.com

Guardar y salir.

Actualizar /etc/hosts

# Respaldar archivo hosts
sudo cp /etc/hosts /etc/hosts.backup

# Editar archivo hosts
sudo nano /etc/hosts

Actualizar para incluir FQDN:

127.0.0.1       localhost
127.0.1.1       web01.example.com web01

# IP pública de tu servidor (si aplica)
203.0.113.10    web01.example.com web01

# localhost IPv6
::1             localhost ip6-localhost ip6-loopback
ff02::1         ip6-allnodes
ff02::2         ip6-allrouters

Importante: La línea con 127.0.1.1 debe listar FQDN primero, luego nombre de host corto.

Aplicar Cambios

# Reiniciar servicio hostname (si no usas hostnamectl)
sudo systemctl restart systemd-hostnamed

# O simplemente iniciar nuevo shell
bash

# Verificar
hostname
hostname -f

Consideraciones de Cloud-init (Instancias en la Nube)

Si usas cloud-init (AWS, DigitalOcean, etc.):

# Editar configuración de cloud-init
sudo nano /etc/cloud/cloud.cfg

Encontrar y modificar:

# Prevenir que cloud-init sobrescriba hostname
preserve_hostname: true

O establecer nombre de host deseado en cloud-init:

# Establecer hostname vía cloud-init
hostname: web01
fqdn: web01.example.com

Paso 4: Establecer Nombre de Host en CentOS/Rocky Linux

Usando hostnamectl (Recomendado)

# Establecer nombre de host estático
sudo hostnamectl set-hostname web01

# Establecer FQDN
sudo hostnamectl set-hostname web01.example.com

# Establecer nombre de host bonito
sudo hostnamectl set-hostname "Servidor Web 01" --pretty

# Verificar
hostnamectl
hostname
hostname -f

Usando nmcli (NetworkManager)

# Establecer nombre de host vía NetworkManager
sudo nmcli general hostname web01.example.com

# Reiniciar NetworkManager
sudo systemctl restart NetworkManager

# Verificar
hostname -f

Editando /etc/hostname

# Respaldar archivo hostname
sudo cp /etc/hostname /etc/hostname.backup.$(date +%Y%m%d)

# Editar archivo hostname
sudo vi /etc/hostname

# O usar echo
echo "web01.example.com" | sudo tee /etc/hostname

Actualizar /etc/hosts

# Respaldar archivo hosts
sudo cp /etc/hosts /etc/hosts.backup

# Editar archivo hosts
sudo vi /etc/hosts

Configurar:

127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6

# Dirección IP real del servidor
203.0.113.10  web01.example.com web01

Contexto SELinux

En sistemas basados en RHEL con SELinux:

# Verificar contexto SELinux para archivo hostname
ls -Z /etc/hostname

# Restaurar contexto si es necesario
sudo restorecon -v /etc/hostname

Aplicar Cambios

# Reiniciar systemd-hostnamed
sudo systemctl restart systemd-hostnamed

# Iniciar nuevo shell para ver cambios
bash

# Verificar cambios
hostname
hostname -f
hostnamectl

Método Legacy RHEL 6 (para referencia)

# Editar configuración de red (RHEL 6 y anteriores)
sudo vi /etc/sysconfig/network

# Establecer:
HOSTNAME=web01.example.com

# Aplicar sin reiniciar
sudo hostname web01.example.com

Paso 5: Configurar FQDN en /etc/hosts

El archivo /etc/hosts mapea nombres de host a direcciones IP para resolución DNS local.

Configuración de Mejores Prácticas

# Editar archivo hosts
sudo nano /etc/hosts

Estructura recomendada:

# Entradas de loopback
127.0.0.1   localhost
127.0.1.1   web01.example.com web01

# IP pública del servidor (si es estática)
203.0.113.10  web01.example.com web01

# IP privada del servidor (si está en VPC/red privada)
10.0.1.10  web01.example.com web01

# loopback IPv6
::1         localhost ip6-localhost ip6-loopback
fe00::0     ip6-localnet
ff00::0     ip6-mcastprefix
ff02::1     ip6-allnodes
ff02::2     ip6-allrouters

# Otros hosts en tu red (opcional)
203.0.113.11  web02.example.com web02
203.0.113.12  db01.example.com db01
10.0.1.20     app01.internal.example.com app01

El orden importa: Listar FQDN antes del nombre de host corto.

Correcto:

203.0.113.10  web01.example.com web01

Incorrecto:

203.0.113.10  web01 web01.example.com

Direcciones IP Especiales

127.0.0.1 vs 127.0.1.1:

  • 127.0.0.1: Reservado para localhost
  • 127.0.1.1: Usado en Debian/Ubuntu para nombre de host local (no existe en todos los sistemas)

Mejor práctica:

# Usar 127.0.0.1 solo para localhost
127.0.0.1   localhost

# Usar 127.0.1.1 o IP real para nombre de host
127.0.1.1   hostname.domain.com hostname
# O
203.0.113.10  hostname.domain.com hostname

Consideraciones de Entorno en la Nube

AWS EC2:

# IP privada
172.31.10.100  web01.ec2.internal web01

# IP pública (si es estática)
203.0.113.10  web01.example.com web01

Redes privadas:

# IP interna para comunicación interna
10.0.1.10  web01.internal.example.com web01

# IP pública para acceso externo
203.0.113.10  web01.example.com web01-external

Probar Configuración de /etc/hosts

# Probar resolución de nombre de host
ping -c 2 $(hostname)
ping -c 2 $(hostname -f)

# Verificar que se usa /etc/hosts
getent hosts $(hostname)
getent hosts $(hostname -f)

# Verificar orden de resolución
cat /etc/nsswitch.conf | grep hosts
# Debería mostrar: hosts: files dns (files = /etc/hosts, verificado primero)

Paso 6: Configurar Registros DNS

Para resolución FQDN apropiada desde otros sistemas, configura registros DNS.

Registros DNS Requeridos

Registro A (IPv4):

# Formato: hostname IN A dirección-ip
web01.example.com.  IN  A  203.0.113.10

Registro AAAA (IPv6):

# Formato: hostname IN AAAA dirección-ipv6
web01.example.com.  IN  AAAA  2001:db8::1

Registro PTR (DNS Inverso):

# Formato: ip-inversa.in-addr.arpa. IN PTR fqdn
10.113.0.203.in-addr.arpa.  IN  PTR  web01.example.com.

Usando Panel de Control del Proveedor DNS

Proveedores DNS comunes:

  • Cloudflare
  • AWS Route 53
  • Google Cloud DNS
  • DigitalOcean DNS
  • Namecheap
  • GoDaddy

Pasos típicos:

  1. Iniciar sesión en proveedor DNS
  2. Seleccionar tu dominio
  3. Agregar registro A:
    • Tipo: A
    • Nombre: web01 (o @ para dominio raíz)
    • Valor: 203.0.113.10
    • TTL: 3600 (o por defecto)

Usando Línea de Comandos (bind9/named)

Si gestionas tu propio servidor DNS:

# Editar archivo de zona
sudo nano /var/named/example.com.zone

# O en Debian/Ubuntu
sudo nano /etc/bind/db.example.com

Agregar registros:

$TTL 86400
@   IN  SOA  ns1.example.com. admin.example.com. (
            2024011001  ; Serial
            3600        ; Refresh
            1800        ; Retry
            604800      ; Expire
            86400 )     ; Minimum TTL

; Servidores de nombres
@       IN  NS   ns1.example.com.
@       IN  NS   ns2.example.com.

; Registros A
@       IN  A    203.0.113.10
www     IN  A    203.0.113.10
web01   IN  A    203.0.113.10
mail    IN  A    203.0.113.11

; Registros MX
@       IN  MX 10 mail.example.com.

; Registros CNAME
ftp     IN  CNAME  web01.example.com.

Recargar servicio DNS:

# BIND9
sudo systemctl reload named
# O
sudo rndc reload

Verificar Configuración DNS

# Probar registro A
dig web01.example.com
nslookup web01.example.com
host web01.example.com

# Probar desde DNS externo
dig @8.8.8.8 web01.example.com
dig @1.1.1.1 web01.example.com

# Probar DNS inverso
dig -x 203.0.113.10
host 203.0.113.10

# Verificar propagación DNS
# Usar herramientas en línea:
# - https://www.whatsmydns.net/
# - https://dnschecker.org/

Tiempo de Propagación DNS

  • TTL (Time To Live): Determina duración de caché
  • Propagación típica: 1-48 horas
  • Reducir TTL antes de cambios: Para propagación más rápida
  • Aumentar TTL después: Para reducir carga de consulta DNS
# Verificar TTL actual
dig web01.example.com | grep "^web01"
# Buscar número después del nombre de host (ej., 3600 = 1 hora)

Paso 7: Verificar la Configuración del Nombre de Host y FQDN

Comandos de Verificación Completa

# Mostrar toda la información del nombre de host
hostnamectl status

# Nombre de host corto
hostname

# FQDN
hostname -f
hostname --fqdn

# Solo nombre de dominio
hostname -d

# Todos los nombres
hostname -A

# Direcciones IP
hostname -I
hostname -i

Probar Resolución

# Resolución local (/etc/hosts)
getent hosts $(hostname)
getent hosts $(hostname -f)

# Resolución DNS
nslookup $(hostname -f)
dig $(hostname -f)
host $(hostname -f)

# DNS inverso
dig -x $(hostname -I | awk '{print $1}')

Prueba de Aplicación

# Probar con comando mail
echo "Test" | mail -s "Prueba de hostname desde $(hostname -f)" [email protected]

# Verificar hostname de postfix
postconf myhostname

# Probar con curl
curl -I http://$(hostname -f)

# Probar con openssl
openssl s_client -connect $(hostname -f):443 -servername $(hostname -f)

Crear Script de Verificación

# Crear script de verificación de hostname
cat << 'EOF' | sudo tee /usr/local/bin/verify-hostname.sh
#!/bin/bash

echo "=== Verificación de Nombre de Host ==="
echo ""

echo "Nombre de host corto: $(hostname)"
echo "FQDN: $(hostname -f)"
echo "Dominio: $(hostname -d)"
echo "Direcciones IP: $(hostname -I)"
echo ""

echo "=== /etc/hostname ==="
cat /etc/hostname
echo ""

echo "=== /etc/hosts (líneas relevantes) ==="
grep $(hostname) /etc/hosts
echo ""

echo "=== hostnamectl ==="
hostnamectl
echo ""

echo "=== Resolución DNS ==="
echo "Resolución local:"
getent hosts $(hostname -f)
echo ""

echo "Consulta DNS:"
dig +short $(hostname -f)
echo ""

echo "DNS inverso:"
dig +short -x $(hostname -I | awk '{print $1}')
echo ""

echo "=== Verificación Completa ==="

EOF

sudo chmod +x /usr/local/bin/verify-hostname.sh
sudo /usr/local/bin/verify-hostname.sh

Paso 8: Configuración de Nombre de Host Específica de Aplicación

Servidor de Correo (Postfix)

# Editar configuración principal de Postfix
sudo nano /etc/postfix/main.cf

# Establecer parámetros de hostname
myhostname = mail.example.com
mydomain = example.com
myorigin = $mydomain

# Reiniciar Postfix
sudo systemctl restart postfix

# Probar configuración
postconf -n | grep hostname
echo "Test" | mail -s "Test" [email protected]

Servidor Web Apache

# Editar configuración de Apache
sudo nano /etc/apache2/apache2.conf  # Debian/Ubuntu
sudo nano /etc/httpd/conf/httpd.conf  # CentOS/Rocky

# Establecer ServerName
ServerName web01.example.com:80

# En configuración de virtual host
<VirtualHost *:80>
    ServerName www.example.com
    ServerAlias example.com
    DocumentRoot /var/www/html
</VirtualHost>

# Probar y reiniciar
sudo apachectl configtest
sudo systemctl restart apache2  # o httpd

Servidor Web Nginx

# Editar configuración de Nginx
sudo nano /etc/nginx/nginx.conf

# O en bloque de servidor
sudo nano /etc/nginx/sites-available/default

# Establecer server_name
server {
    listen 80;
    server_name web01.example.com www.example.com;

    root /var/www/html;
    index index.html;
}

# Probar y reiniciar
sudo nginx -t
sudo systemctl restart nginx

MySQL/MariaDB

# Editar configuración de MySQL
sudo nano /etc/mysql/my.cnf

# Establecer hostname en sección [mysqld]
[mysqld]
hostname = db01.example.com

# O establecer en configuración de replicación
report_host = db01.example.com

# Reiniciar MySQL
sudo systemctl restart mysql

Certificados SSL/TLS

# Generar CSR con FQDN correcto
openssl req -new -newkey rsa:2048 -nodes \
  -keyout server.key -out server.csr \
  -subj "/C=US/ST=State/L=City/O=Company/CN=web01.example.com"

# Let's Encrypt con Certbot
sudo certbot certonly --standalone -d web01.example.com -d www.example.com

# Verificar que el certificado coincide con hostname
openssl x509 -in /etc/ssl/certs/server.crt -text -noout | grep CN

Sistemas de Monitoreo

# Prometheus node_exporter
# Usa hostname automáticamente

# Configuración de Grafana
sudo nano /etc/grafana/grafana.ini

[server]
domain = grafana.example.com
root_url = https://grafana.example.com

# Reiniciar Grafana
sudo systemctl restart grafana-server

Casos de Uso Comunes

Configuración de Servidor Web

# Establecer hostname
sudo hostnamectl set-hostname web01.example.com

# Configurar /etc/hosts
echo "203.0.113.10  web01.example.com web01 www.example.com" | sudo tee -a /etc/hosts

# Configurar Apache/Nginx ServerName
# Agregar registros DNS A para web01.example.com y www.example.com

# Obtener certificado SSL
sudo certbot --apache -d web01.example.com -d www.example.com

Configuración de Servidor de Correo

# Establecer hostname para coincidir con registro MX
sudo hostnamectl set-hostname mail.example.com

# Configurar /etc/hosts
echo "203.0.113.11  mail.example.com mail" | sudo tee -a /etc/hosts

# Configurar Postfix
sudo postconf -e "myhostname = mail.example.com"
sudo postconf -e "mydomain = example.com"

# Agregar registros DNS:
# MX: example.com -> mail.example.com (prioridad 10)
# A: mail.example.com -> 203.0.113.11
# PTR: 11.113.0.203.in-addr.arpa -> mail.example.com

Configuración de Servidor de Base de Datos

# Establecer hostname
sudo hostnamectl set-hostname db01.internal.example.com

# Configurar /etc/hosts (usar IP interna)
echo "10.0.1.20  db01.internal.example.com db01" | sudo tee -a /etc/hosts

# Configurar hostname de MySQL
sudo mysql -e "SET GLOBAL hostname='db01.internal.example.com';"

# Agregar registro DNS A interno

Configuración de Nodo Kubernetes

# Establecer hostname único para cada nodo
sudo hostnamectl set-hostname k8s-worker-01.example.com

# Asegurar que el hostname es resoluble por DNS
# Configurar /etc/hosts con todos los nodos

echo "10.0.1.10  k8s-master-01.example.com k8s-master-01" | sudo tee -a /etc/hosts
echo "10.0.1.20  k8s-worker-01.example.com k8s-worker-01" | sudo tee -a /etc/hosts
echo "10.0.1.21  k8s-worker-02.example.com k8s-worker-02" | sudo tee -a /etc/hosts

Verificación

Lista de Verificación Completa

# 1. Verificar hostname
hostname
# Esperado: web01

# 2. Verificar FQDN
hostname -f
# Esperado: web01.example.com

# 3. Verificar dominio
hostname -d
# Esperado: example.com

# 4. Verificar /etc/hostname
cat /etc/hostname
# Esperado: web01.example.com

# 5. Verificar /etc/hosts
grep $(hostname) /etc/hosts
# Esperado: IP FQDN hostname

# 6. Resolución local
getent hosts $(hostname -f)
# Esperado: IP FQDN

# 7. Resolución DNS
dig +short $(hostname -f)
# Esperado: IP del servidor

# 8. DNS inverso
dig +short -x $(hostname -I | awk '{print $1}')
# Esperado: FQDN

# 9. Estado de hostnamectl
hostnamectl
# Verificar que todos los campos son correctos

# 10. Probar desde servidor remoto
ssh remote-server "dig $(hostname -f)"
ssh remote-server "ping -c 2 $(hostname -f)"

Solución de Problemas

El Nombre de Host No Persiste Después del Reinicio

Problema: El nombre de host vuelve al valor por defecto después del reinicio.

Solución:

# Asegurar que /etc/hostname es correcto
cat /etc/hostname

# Verificar cloud-init (si es instancia en nube)
sudo nano /etc/cloud/cloud.cfg
# Establecer: preserve_hostname: true

# Verificar NetworkManager
sudo nano /etc/NetworkManager/NetworkManager.conf
# Agregar en [main]:
# hostname-mode=none

# Verificar que el hostname está establecido persistentemente
sudo hostnamectl set-hostname web01.example.com

# Reiniciar y probar
sudo reboot
# Después del reinicio:
hostname -f

FQDN Devuelve "hostname: Name or service not known"

Problema: hostname -f falla o devuelve nombre de host corto.

Solución:

# Verificar que /etc/hosts tiene FQDN
grep $(hostname) /etc/hosts

# Asegurar que FQDN viene antes del nombre de host corto
# Correcto:
echo "203.0.113.10  web01.example.com web01" | sudo tee -a /etc/hosts

# Incorrecto:
# 203.0.113.10  web01 web01.example.com

# Verificar que nsswitch usa archivo hosts
cat /etc/nsswitch.conf | grep hosts
# Debería mostrar: hosts: files dns

# Probar
hostname -f

DNS No Resuelve el Nombre de Host

Problema: Las consultas DNS para el nombre de host fallan.

Solución:

# Verificar configuración DNS
cat /etc/resolv.conf

# Probar con servidor DNS específico
dig @8.8.8.8 web01.example.com
dig @1.1.1.1 web01.example.com

# Verificar si existen registros DNS
nslookup web01.example.com
host web01.example.com

# Esperar propagación DNS (hasta 48 horas)
# Verificar estado de propagación:
# https://www.whatsmydns.net/

# Limpiar caché DNS local
sudo systemd-resolve --flush-caches  # Ubuntu 18+
sudo resolvectl flush-caches         # Ubuntu 20+
sudo systemctl restart systemd-resolved

Desajuste de DNS Inverso

Problema: El DNS inverso no coincide con el DNS directo.

Solución:

# Verificar DNS inverso
dig -x $(hostname -I | awk '{print $1}')
host $(hostname -I | awk '{print $1}')

# Contactar al proveedor de hosting o administrador DNS para establecer registro PTR
# El registro PTR debe apuntar a tu FQDN

# Para servidores de correo, esto es crítico:
dig -x TU_IP +short
# Debería devolver: mail.example.com

Problemas de Nombre de Host del Servidor de Correo

Problema: Correos rechazados debido a desajuste de nombre de host.

Solución:

# Asegurar que FQDN coincide con registro MX
hostname -f
# Debe coincidir con FQDN del registro MX

# Verificar configuración de Postfix
postconf myhostname
# Debe coincidir con FQDN

# Verificar DNS inverso
dig -x $(hostname -I | awk '{print $1}') +short
# Debe coincidir con DNS directo

# Probar encabezados de correo
echo "Test" | mail -s "Test" [email protected]
# Verificar encabezados de correo recibido para hostname

# Verificar registros SPF y PTR
dig TXT example.com | grep spf
dig -x TU_IP

Múltiples Nombres de Host o Alias

Problema: Necesita múltiples nombres para el mismo servidor.

Solución:

# Agregar alias en /etc/hosts
203.0.113.10  web01.example.com web01 www.example.com app.example.com

# O usar registros CNAME DNS
# www.example.com CNAME web01.example.com
# app.example.com CNAME web01.example.com

# En configuración de servidor web, usar ServerAlias (Apache) o múltiples server_name (Nginx)
ServerAlias www.example.com app.example.com

Mejores Prácticas

Mejores Prácticas de Nomenclatura

  1. Usar nombres descriptivos: Indicar función y entorno
  2. Seguir convenciones: Establecer estándares organizacionales
  3. Planificar para escala: Usar secuencias numeradas
  4. Incluir ubicación: Códigos geográficos o de centro de datos
  5. Evitar cambios: Los cambios de nombre de host pueden romper aplicaciones

Mejores Prácticas de Configuración

  1. Documentar nombres de host: Mantener inventario
  2. Usar DNS cuando sea posible: No depender solo de /etc/hosts
  3. Configurar DNS inverso: Esencial para servidores de correo
  4. Probar exhaustivamente: Verificar resolución desde múltiples fuentes
  5. Automatizar aprovisionamiento: Usar gestión de configuración

Mejores Prácticas de Seguridad

  1. No exponer topología interna: Usar nombres externos genéricos
  2. Separar interno/externo: Nombres diferentes para cada uno
  3. Usar DNS privado: Para servicios internos
  4. Implementar DNSSEC: Para seguridad DNS
  5. Monitorear cambios DNS: Alertar sobre modificaciones inesperadas

Mejores Prácticas Operativas

# Crear script de configuración estandarizado
cat << 'EOF' | sudo tee /usr/local/bin/setup-hostname.sh
#!/bin/bash

# Uso: ./setup-hostname.sh NOMBRE_CORTO DOMINIO IP

NOMBRE_CORTO=$1
DOMINIO=$2
IP=$3
FQDN="${NOMBRE_CORTO}.${DOMINIO}"

# Validar entradas
if [ -z "$NOMBRE_CORTO" ] || [ -z "$DOMINIO" ] || [ -z "$IP" ]; then
    echo "Uso: $0 nombre_corto dominio dirección_ip"
    exit 1
fi

# Respaldar configuración existente
cp /etc/hostname /etc/hostname.backup.$(date +%Y%m%d)
cp /etc/hosts /etc/hosts.backup.$(date +%Y%m%d)

# Establecer hostname
hostnamectl set-hostname $FQDN

# Actualizar /etc/hosts
cat > /etc/hosts << HOSTS
127.0.0.1   localhost
127.0.1.1   $FQDN $NOMBRE_CORTO
$IP         $FQDN $NOMBRE_CORTO

::1         localhost ip6-localhost ip6-loopback
ff02::1     ip6-allnodes
ff02::2     ip6-allrouters
HOSTS

# Verificar
echo "Hostname establecido a: $(hostname -f)"
echo "Verificación:"
hostname -f
getent hosts $FQDN

EOF

sudo chmod +x /usr/local/bin/setup-hostname.sh

Plantilla de Documentación

# Crear documentación de hostname
cat > /root/hostname-config.txt << EOF
Configuración de Nombre de Host
================================
Fecha de Configuración: $(date)
Configurado Por: $(whoami)

Nombre de Host: $(hostname)
FQDN: $(hostname -f)
Dominio: $(hostname -d)

Direcciones IP:
  Pública: $(hostname -I)
  Privada: (listar si es diferente)

Registros DNS:
  Registro A: $(hostname -f) -> $(hostname -I | awk '{print $1}')
  Registro PTR: $(dig -x $(hostname -I | awk '{print $1}') +short)

Propósito: [Servidor Web / Base de Datos / Correo / etc.]
Entorno: [Producción / Staging / Desarrollo]

Servicios Asociados:
  - [Listar servicios que dependen del hostname]

Notas:
  - [Cualquier configuración especial o consideraciones]

EOF

Conclusión

La configuración apropiada del nombre de host y FQDN es fundamental para la gestión de servidores Linux, afectando todo desde redes básicas hasta funcionalidad de aplicaciones y seguridad. Siguiendo esta guía completa, has aprendido cómo configurar correctamente nombres de host en diferentes distribuciones de Linux, configurar registros DNS y verificar tu configuración.

Logros clave:

  • Comprensión de conceptos de nombre de host, FQDN y dominio
  • Capacidad de verificar configuración actual de nombre de host
  • Conocimiento de convenciones de nomenclatura de nombres de host
  • Habilidades de configuración para Ubuntu/Debian y CentOS/Rocky Linux
  • Configuración apropiada del archivo /etc/hosts
  • Configuración de registros DNS
  • Configuración de nombre de host específica de aplicación
  • Solución de problemas comunes de nombre de host

Recordatorios importantes:

  • FQDN debe ser resoluble por DNS para servicios públicos
  • DNS inverso es crítico para servidores de correo
  • /etc/hosts proporciona respaldo de resolución local
  • Los cambios de nombre de host pueden requerir reconfiguración de aplicación
  • Siempre probar exhaustivamente después de cambios de nombre de host

Próximos pasos:

  • Configurar monitoreo para rastrear cambios de nombre de host
  • Implementar gestión automatizada de nombre de host en aprovisionamiento
  • Configurar monitoreo y alertas DNS
  • Documentar todos los nombres de host en inventario central
  • Auditorías regulares de configuraciones de nombre de host

Manteniendo configuraciones de nombre de host consistentes y bien documentadas en toda tu infraestructura, asegurarás una operación de servicio confiable y una solución de problemas más fácil.

Recursos Adicionales

Guías Relacionadas

  • Configuración de Seguridad Inicial en Ubuntu/Debian
  • Configuración de Seguridad Inicial en CentOS/Rocky Linux
  • Cómo Configurar DNS Inverso (rDNS/PTR)
  • Servidor DNS con BIND9
  • Configuración de Servidor de Correo con Postfix
  • Instalación y Configuración de Nginx en Linux
  • Instalación y Configuración de Apache en Linux