223 votes

Définition du nom d'hôte : FQDN ou nom court ?

J'ai remarqué que la méthode " préférée " pour définir le nom d'hôte du système est fondamentalement différente entre les systèmes Red Hat/CentOS et Debian/Ubuntu.

Documentation CentOS et le Guide de déploiement RHEL dites le nom d'hôte doit être le FQDN :

HOSTNAME=<value> , donde <value> doit être le domaine pleinement qualifié (FQDN), tel que hostname.example.com mais peut être n'importe quel nom d'hôte est nécessaire.

El Guide d'installation de RHEL est légèrement plus ambiguë :

Le programme d'installation vous invite à fournir un nom d'hôte pour cet ordinateur, sous la forme d'un nom d'utilisateur ou d'un nom de domaine. nom de domaine entièrement qualifié (FQDN) dans le format nom d'hôte.nom de domaine ou comme un nom d'hôte court au format nom d'hôte .

La référence Debian indique le nom d'hôte ne doit pas utiliser le FQDN :

3.5.5. Le nom d'hôte

Le noyau maintient le système nom d'hôte . L'init script dans le niveau d'exécution S qui est lié par un lien symbolique à " /etc/init.d/hostname.sh " définit le nom d'hôte du système au démarrage (en utilisant l'option nom d'hôte ) au nom enregistré dans " /etc/hostname ". Ce fichier doit contenir sólo le nom d'hôte du système, et non un nom de domaine entièrement qualifié.

Je n'ai pas vu de recommandations spécifiques de la part d'IBM sur ce qu'il faut utiliser, mais certains logiciels semble avoir une préférence.

Mes questions :

  • Dans un environnement hétérogène, est-il préférable d'utiliser la recommandation du fournisseur, ou d'en choisir une et d'être cohérent sur tous les hôtes ?
  • Quel logiciel avez-vous rencontré qui soit sensible au fait que le nom d'hôte soit défini sur le FQDN ou le nom court ?

128voto

ewwhite Points 193555

Je choisirais une approche cohérente pour l'ensemble de l'environnement. Les deux solutions fonctionnent bien et resteront compatibles avec la plupart des applications. Il existe toutefois une différence au niveau de la facilité de gestion.

J'utilise le nom court comme paramètre HOSTNAME, et je définis le FQDN comme première colonne dans le fichier /etc/hosts pour l'IP du serveur, suivi du nom court.

Je n'ai pas rencontré beaucoup de logiciels qui imposent ou affichent une préférence entre les deux. Je trouve que le nom court est plus propre pour certaines applications, notamment la journalisation. Peut-être ai-je eu la malchance de voir des domaines internes tels que server.northside.chicago.rizzomanufacturing.com . Qui veut voir cela dans les journaux ou dans une Shell invite ?

Parfois, je suis impliqué dans des acquisitions ou des restructurations d'entreprises où les domaines et/ou sous-domaines internes changent. J'aime utiliser le nom d'hôte court dans ces cas, car la journalisation, les démarrages, l'impression, la surveillance des systèmes, etc. n'ont pas besoin d'une reconfiguration complète pour tenir compte des nouveaux noms de domaine.

Une configuration typique de serveur RHEL/CentOS pour un serveur nommé "rizzo" avec un domaine interne "ifp.com", ressemblerait à ceci :

/etc/sysconfig/network:
HOSTNAME=rizzo
...

-

/etc/hosts:
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6

172.16.100.13   rizzo.ifp.com rizzo

-

[root@rizzo ~]# hostname 
rizzo

-

/var/log/messages snippet:
Dec 15 10:10:13 rizzo proftpd[19675]: 172.16.100.13 (::ffff:206.15.236.182[::ffff:206.15.236.182]) - Preparing to               
 chroot to directory '/app/upload/GREEK'
Dec 15 10:10:51 rizzo proftpd[20660]: 172.16.100.13 (::ffff:12.28.170.2[::ffff:12.28.170.2]) - FTP session opened.
Dec 15 10:10:51 rizzo proftpd[20660]: 172.16.100.13 (::ffff:12.28.170.2[::ffff:12.28.170.2]) - Preparing to chroot                
to directory '/app/upload/ftp/SRRID'

11 votes

Comme vous, je préfère le nom court, mais j'ai découvert récemment que certaines applications Oracle requièrent la sortie de hostname pour être le FQDN. Le fait de l'avoir dans /etc/hosts n'est pas assez bon. Cela a perturbé ma cohérence.

4 votes

La différence de capitalisation des noms d'hôtes dans cet exemple n'est certainement pas une bonne pratique : outils.ietf.org/search/rfc1178

2 votes

Il ne faut pas /etc/sysconfig/network contiennent des lignes comme : NETWORKING=yes , NETWORKING_IPV6=no , HOSTNAME=example.com , NISDOMAIN=example ?

47voto

Armend Krasniqi Points 61

Presque tous les logiciels sont sensibles à la définition correcte du nom d'hôte. Lorsque je travaillais chez Digg, j'ai une fois fait tomber tout le site pendant 2 heures à cause d'un changement apparemment innocent dans le nom de l'hôte. /etc/hosts qui affectait la notion de nom d'hôte du système. Soyez prudent. Cela dit, il se peut que vous soyez légèrement confus ici. Je ne pense pas que le HOSTNAME= est directement équivalent à la façon dont les distributions basées sur Debian utilisent le paramètre /etc/hostname .

Ce qui fonctionne pour moi dans un environnement hétérogène est :

  1. Définissez le nom d'hôte de la manière recommandée par le fournisseur, en utilisant une condition dans votre logiciel de gestion de la configuration.
  2. Utilisez le hostname pour définir le nom d'hôte utilisé par le noyau, etc.
  3. Sur /etc/hosts :

    127.0.0.1    localhost
    10.0.0.1     hostname.example.com     hostname

Cette configuration ne m'a pas encore fait défaut.

0 votes

C'est à peu près la configuration que j'utilise au travail. Le nom court devrait convenir tant que le nom de domaine figure dans le chemin de recherche DNA (/etc/resolv.conf) pour les machines concernées dans votre environnement.

0 votes

Recommandez-vous spécifiquement une IP de réseau local plutôt qu'une IP publique ?

41voto

stew Points 9143

Vous n'aurez certainement aucun problème à trouver des références en ligne qui vous diront qu'il faut absolument le faire d'une manière ou d'une autre. Il me semble cependant que le fait d'avoir un nom court comme nom d'hôte, et d'avoir le nom pleinement qualifié dans /etc/hosts est certainement beaucoup plus répandu. Cela semble être la méthode la plus raisonnable, car les services qui ont besoin d'un nom pleinement qualifié peuvent être adaptés pour appeler hostname --fqdn à la place.

Je n'ai rencontré qu'un seul logiciel récemment qui exigeait de manière rigide qu'un fqdn soit retourné par hostname qui était ganeti. Ils documentent ceci aquí . Je ne vois pas pourquoi ils ne pourraient pas s'adapter à hostname --fqdn Cependant.

2 votes

" Je ne vois pas pourquoi ils ne pourraient pas s'adapter à hostname --fqdn La réponse à la question "Pourquoi un nom d'hôte pleinement qualifié" se trouve dans le premier paragraphe de la section "Pourquoi un nom d'hôte pleinement qualifié" -- elle nécessite des conjectures et un résolveur fonctionnel. Demander au noyau est l'option la plus sûre et la plus fiable.

5 votes

@womble - Tant que le fichier /etc/hosts contient une entrée pour la machine ( 10.0.0.1 hostname.example.com hostname ) et /etc/nsswitch.conf spécifie la résolution locale avant le DNS ( hosts: files dns ), la présence d'un résolveur fonctionnel est assurée par le fichier hosts local. En tant que tel, l'argument en faveur de l'utilisation d'un FQDN au lieu d'un nom d'hôte tient rarement la route. De plus, un autre exemple de logiciel qui exige de manière rigide hostname pour retourner un FQDN est le paquet du serveur de messagerie Zimbra.

1 votes

@crashmaxed : C'est plusieurs exigences supplémentaires, dont chacune pourrait ne pas être possible dans un environnement donné ou foirée par erreur. Avoir le FQDN dans les structures de données du noyau est beaucoup plus simple.

17voto

David Tonhofer Points 900

Quelque peu tangentiellement, tout en recherchant cette question, je suis devenu assez fou pour vérifier le code source de "hostname" et écrire un script pour imprimer les résultats de l'enquête (Fedora 19). Ce qui manque, c'est un regard sur "/etc/hosts", qui, à mon humble avis, devrait être tenu à l'écart de tout cela en premier lieu.

#!/bin/bash

function pad {
   if [[ $1 == '?' ]]; then
      printf "%-23s" "?"
   else
      printf "%-23s" "'$1'"
   fi
}

# ----- Kernel -----

# Two ways to configure the kernel values: 
# 1) Put FQDN into "kernel.hostname" and nothing into "kernel.domainname"
# 2) Put machine name into "kernel.hostname" and DNS domain name into "kernel.domainname" (makes more sense)

echo "== Kernel values =="
echo

H=`/sbin/sysctl -n kernel.hostname`
D=`/sbin/sysctl -n kernel.domainname`

echo "Kernel hostname: '$H'"
echo "Kernel domainname: '$D'"

# ----- What does bash say -----

echo
echo "== According to bash =="
echo

echo "HOSTNAME = '$HOSTNAME'"

# ----- Hostname config file ------

echo
echo "== Hostname config file =="
echo

ETCH="/etc/hostname"

if [[ -f $ETCH ]]; then
   CONTENTS=`cat $ETCH`
   echo "File '$ETCH' contains: '$CONTENTS'"
else
   echo "File '$ETCH' does not exist"
fi

# ----- Network config file ------

echo
echo "== Network config file =="
echo

SYSN="/etc/sysconfig/network"

if [[ -f $SYSN ]]; then
   LINE=`grep -e "^HOSTNAME=" $SYSN`
   if [[ -n $LINE ]]; then
      echo "File '$SYSN' contains: '$LINE'"
   else 
      echo "File '$SYSN' exists but does not contain a line for 'HOSTNAME'"
   fi
else
   echo "File '$SYSN' does not exist"
fi

# ----- Nodename -------

echo
echo "== Nodename =="
echo

UNAME=`uname --nodename` # On Linux, this is the hostname

echo "The 'nodename' given by 'uname --nodename' is: '$UNAME'"

# ----- The 'hostname' mess ------

THE_HOSTNAME=`hostname`
SHORT_NAME=`hostname --short`
NIS_DNAME=`domainname`     
YP_DNAME=`hostname --yp`    # Same as `nisdomainname` ; this may fail with "hostname: Local domain name not set"

if [[ $? != 0 ]]; then
   YP_DNAME="?"
fi

echo
echo "== 'hostname' directly obtained values =="
echo
echo "The result of gethostname();"
echo "...obtained by running 'hostname'"
echo "Hostname: $(pad $THE_HOSTNAME)"
echo
echo "The part before the first '.' of the value returned by gethostname();"
echo "...obtained by running 'hostname --short'"
echo "Short name: $(pad $SHORT_NAME)"
echo
echo "The result of getdomainname(); the code of 'hostname' seems to call this the 'NIS domain name';"
echo "...on Linux, this is the kernel-configured domainname;"
echo "...obtained by running 'domainname'"
echo "NIS domain name: $(pad $NIS_DNAME)"
echo
echo "The result of yp_get_default_domain(), which may fail;"
echo "...obtained by running 'hostname --yp'"
echo "YP default domain: $(pad $YP_DNAME)"

DNS_DNAME=`hostname --domain`  # Same as `dnsdomainname`'
FQDN_NAME=`hostname --fqdn`
ALIAS_NAME=`hostname --alias`

echo
echo "== 'hostname' values obtained via DNS =="
echo
echo "The part after the first '.' of the 'canonical name' value returned by getaddrinfo(gethostname());"
echo "...obtained by running 'hostname --domain'"
echo "DNS domain name: $(pad $DNS_DNAME)"
echo
echo "The 'canonical name' value returned by getaddrinfo(gethostname());"
echo "...obtained by running 'hostname --fqdn'"
echo "Fully qualified hostname: $(pad $FQDN_NAME)"
echo
echo "Alias obtained by gethostbyname(gethostname());"
echo "...obtained by running 'hostname --alias'"
echo "Hostname alias: $(pad $ALIAS_NAME)"

BY_IP_ADDR=`hostname --ip-address`
ALL_IP_ADDR=`hostname --all-ip-addresses`
ALL_FQDN_NAMES=`hostname --all-fqdn`

echo
echo "== 'hostname' values obtained by collecting configured network addresses =="
echo
echo "Collect the IP addresses from getaddrinfo(gethostname()), apply getnameinfo(ip) to all those addresses;"
echo "...obtained by running 'hostname --ip-address'"
echo "By IP address: $BY_IP_ADDR"
echo
echo "Call getnameinfo(NI_NUMERICHOST) on all addresses snarfed from active interfaces;"
echo "...obtained by running 'hostname --all-ip-addresses'"
echo "All IP addresses: $ALL_IP_ADDR"
echo
echo "Call getnameinfo(NI_NAMEREQD) on all addresses snarfed from active interfaces (involves lookup in /etc/hosts);"
echo "...obtained by running 'hostname --all-fqdn'"
echo "All fully qualified hostnames: $ALL_FQDN_NAMES"

Le résultat sur une VM Amazon EC2 exécutant Fedora 19 après avoir défini manuellement les valeurs du noyau et rempli le formulaire de demande d'aide. /etc/hostname mais sans modification de l /etc/hosts pourrait alors être comme ceci :

== Kernel values ==

Kernel hostname: 'kyubee'
Kernel domainname: 'homelinux.org'

== According to bash ==

HOSTNAME = 'ip-172-31-24-249.localdomain'

== Hostname config file ==

File '/etc/hostname' contains: 'kyubee.homelinux.org'

== Network config file ==

File '/etc/sysconfig/network' exists but does not contain a line for 'HOSTNAME'

== Nodename ==

The 'nodename' given by 'uname --nodename' is: 'kyubee'

== 'hostname' directly obtained values ==

The result of gethostname();
...obtained by running 'hostname'
Hostname: 'kyubee'

The part before the first '.' of the value returned by gethostname();
...obtained by running 'hostname --short'
Short name: 'kyubee'

The result of getdomainname(); the code of 'hostname' seems to call this the 'NIS domain name';
...on Linux, this is the kernel-configured domainname;
...obtained by running 'domainname'
NIS domain name: 'homelinux.org'

The result of yp_get_default_domain(), which may fail;
...obtained by running 'hostname --yp'
YP default domain: 'homelinux.org'

== 'hostname' values obtained via DNS ==

The part after the first '.' of the 'canonical name' value returned by getaddrinfo(gethostname());
...obtained by running 'hostname --domain'
DNS domain name: ''

The 'canonical name' value returned by getaddrinfo(gethostname());
...obtained by running 'hostname --fqdn'
Fully qualified hostname: 'kyubee'

Alias obtained by gethostbyname(gethostname());
...obtained by running 'hostname --alias'
Hostname alias: ''

== 'hostname' values obtained by collecting configured network addresses ==

Collect the IP addresses from getaddrinfo(gethostname()), apply getnameinfo(ip) to all those addresses;
...obtained by running 'hostname --ip-address'
By IP address: fe80::8f6:8eff:fe49:9e21%eth0 172.31.24.249

Call getnameinfo(NI_NUMERICHOST) on all addresses snarfed from active interfaces;
...obtained by running 'hostname --all-ip-addresses'
All IP addresses: 172.31.24.249

Call getnameinfo(NI_NAMEREQD) on all addresses snarfed from active interfaces (involves lookup in /etc/hosts);
...obtained by running 'hostname --all-fqdn'
All fully qualified hostnames: ip-172-31-24-249.eu-west-1.compute.internal

La façon la plus simple d'obtenir le nom d'hôte entièrement qualifié en perl serait alors :

sub getHostname {

   my $hostname_short = `/bin/hostname --short`;
   if ($? != 0) { print STDERR "Could not execute 'hostname --short' -- exiting\n"; exit 1 }
   chomp $hostname_short;

   my $hostname_long  = `/bin/hostname`;
   if ($? != 0) { print STDERR "Could not execute 'hostname' -- exiting\n"; exit 1 }
   chomp $hostname_long;

   if ($hostname_long =~ /^${hostname_short}\..+$/) {
      # "hostname_long" is a qualified version of "hostname_short"
      return $hostname_long
   }
   else {
      # both hostnames are "short" (and are equal)
      die unless ($hostname_long eq $hostname_short);

      my $domainname = `/bin/domainname`;
      if ($? != 0) { print STDERR "Could not execute 'domainname' -- exiting\n"; exit 1 }
      chomp $domainname;

      if ($domainname eq "(none)") {
         # Change according to taste
         return "${hostname_short}.localdomain"
      }
      else {
         return "${hostname_short}.${domainname}"
      }
   }
}

et dans bash ce serait :

function getHostname {

   local hostname_short=`/bin/hostname --short`

   if [ $? -ne 0 ]; then
      echo "Could not execute 'hostname --short' -- exiting" >&2; exit 1
   fi

   local hostname_long=`/bin/hostname`

   if [ $? -ne 0 ]; then
      echo "Could not execute 'hostname' -- exiting" >&2; exit 1
   fi

   if [[ $hostname_long =~ ^"$hostname_short"\..+$ ]]; then
      # "hostname_long" is a qualified version of "hostname_short"
      echo $hostname_long
   else
      # both hostnames are "short" (and are equal)
      if [[ $hostname_long != $hostname_short ]]; then
         echo "Cannot happen: '$hostname_long' <> '$hostname_short' -- exiting" >&2; exit 1
      fi

      local domainname=`/bin/domainname`

      if [ $? -ne 0 ]; then
         echo "Could not execute 'domainname' -- exiting" >&2; exit 1
      fi

      if [[ domainname == '(none)' ]]; then
         # Change according to taste
         echo "${hostname_short}.localdomain"
      else
         echo "${hostname_short}.${domainname}"
      fi
   fi
}

Notes

Note 1 : HOSTNAME est une variable Shell que bash fournit ("Automatically set to the name of the current host.") mais il n'y a aucune indication sur la façon dont bash arrive à cette valeur.

Note 2 : N'oubliez jamais /etc/hostname dans /boot/initrams-FOO.img ...

4 votes

Désolé si cela devrait être évident, mais quel est le rapport avec la définition du nom d'hôte ?

0 votes

Il s'agit essentiellement des notes que j'ai prises lors de mes recherches pour définir le nom d'hôte de mes instances EC2 Fedora 19. Pour ce qui est du résultat : 1) Définissez le FQHN dans /etc/hostname 2) Ne touchez pas à /etc/hosts 3) Vous pouvez définir le 'kernel hostname' soit avec le FQHN, soit avec le nom d'hôte non qualifié, si non défini, la valeur est prise dans /etc/hostname 4) Vous pouvez définir le 'kernel domainname' avec le nom de domaine, ce qui est plus agréable que juste '(none)'.

-4voto

Riaan Points 411

Les options de /etc/hosts fonctionnent bien.

Mais vous voulez vous assurer que tous les fichiers appropriés sont mis à jour. configuration outil

0 votes

Ma distribution n'a pas d'outil "setup" ; quelle distribution utilisez-vous qui en a un ?

0 votes

Tout système d'exploitation basé sur redhat possède l'outil de configuration rhel/centos/fedora quel système d'exploitation utilisez-vous ?

3 votes

Puisque la question parle des différences entre les distributions basées sur RHEL et celles basées sur Debian, nous devons supposer que le demandeur utilise les deux. Il n'y a pas d'outil " setup " sur les distributions basées sur Debian.

SistemesEz.com

SystemesEZ est une communauté de sysadmins où vous pouvez résoudre vos problèmes et vos doutes. Vous pouvez consulter les questions des autres sysadmins, poser vos propres questions ou résoudre celles des autres.

Powered by:

X