Comment acheminer tous les sous-domaines à un seul hôte en utilisant mDNS?

Question

J'ai un serveur Web de développement d'hébergement comme « myhost.local » qui se trouve en utilisant Bonjour / mDNS. Le serveur est en cours d'exécution avahi-daemon.

Le serveur Web veut aussi gérer les sous-domaines de lui-même. Par exemple, "cat.myhost.local" et "dog.myhost.local" et "guppy.myhost.local".

Étant donné que myhost.local est sur une adresse IP dynamique de dhcp, est-il encore un moyen d'acheminer toutes les demandes de sous-domaines à myhost.local?

Je commence à penser qu'il pas possible ...

http://marc.info/?l=freedesktop-avahi&m=119561596630960&w= 2

  

    

Vous pouvez le faire avec le fichier / etc / avahi / hosts. Sinon, vous pouvez
    utiliser avahi-publish-host-name.

  

     

Non, il ne peut pas. Comme il veut définir un alias, pas une nouvelle   nom d'hôte. C'est à dire. il veut seulement enregistrer un RR, pas PTR inverse RR. Mais   si vous tenez quelque chose dans / etc / Avahi / hosts il enregistre à la fois,   et détecte une collision si le RR PTR est non unique, qui serait le   cas pour un alias.

Answer 1

Je lui ai donné comme pas possible à l'époque, et je ne l'ai pas revu depuis le problème.

Ma solution actuelle est de laborieusement ajouter chaque sous-domaine d'intérêt pour le fichier hosts sur la machine locale.

Answer 2

Je l'ai résolu ce problème mieux que je peux avec le peu de temps que j'affecté à cette tâche.

Mais malheureusement, je ne pense pas que les fenêtres de mise en œuvre avahi / MSDNS / BONJOUR supporte des alias (corrigez-moi si je me trompe avec des exemples de la façon de soutenir ce sujet).

Qu'est-ce que je l'ai fait était commencer par le script python exemple fourni sur le site Avahi:

Créer: /usr/bin/avahi-announce-alias

Faites-exécutable et remplir avec

#! /usr/bin/env python
# avahi-alias.py

import avahi, dbus
from encodings.idna import ToASCII

# Got these from /usr/include/avahi-common/defs.h
CLASS_IN = 0x01
TYPE_CNAME = 0x05

TTL = 60

def publish_cname(cname):
    bus = dbus.SystemBus()
    server = dbus.Interface(bus.get_object(avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER),
            avahi.DBUS_INTERFACE_SERVER)
    group = dbus.Interface(bus.get_object(avahi.DBUS_NAME, server.EntryGroupNew()),
            avahi.DBUS_INTERFACE_ENTRY_GROUP)

    rdata = createRR(server.GetHostNameFqdn())
    cname = encode_dns(cname)

    group.AddRecord(avahi.IF_UNSPEC, avahi.PROTO_UNSPEC, dbus.UInt32(0),
        cname, CLASS_IN, TYPE_CNAME, TTL, rdata)
    group.Commit()


def encode_dns(name):
    out = []
    for part in name.split('.'):
        if len(part) == 0: continue
        out.append(ToASCII(part))
    return '.'.join(out)

def createRR(name):
    out = []
    for part in name.split('.'):
        if len(part) == 0: continue
        out.append(chr(len(part)))
        out.append(ToASCII(part))
    out.append('\0')
    return ''.join(out)

if __name__ == '__main__':
    import time, sys, locale
    for each in sys.argv[1:]:
        name = unicode(each, locale.getpreferredencoding())
        publish_cname(name)
    try:
        # Just loop forever
        while 1: time.sleep(60)
    except KeyboardInterrupt:
        print "Exiting"

Ce script gère l'annonce de chaque alias individuel, et restera en cours d'exécution jusqu'à ce que vous le tuez. (À cause de cela, nous devons créer un autre script que je l'ai indiqué ci-dessous)

Créer un fichier texte /etc/avahi/aliases

Ce que nous utilisons pour les alias de magasin à cette machine une par ligne

Créer un répertoire /etc/avahi/aliases.d/

Je n'ai pas vraiment fait usage de ce que je montre ici encore dans l'un des scripts, mais pour les individus entreprenants là-bas, vous pouvez voir ce qui doit être fait.

L'idée est que vous pouvez les alias de groupe dans des fichiers texte séparés (qui aura plus de sens lorsque vous traitez avec des hôtes virtuels dans apache), c'est quelque chose de nombreuses applications de démon sur * nix fournissent déjà (apache et apt ne sont que deux exemples ).

Créer /usr/bin/avahi-announce-aliases

Faites-exécutable et le remplir avec

#!/usr/bin/env python

import os, sys
from subprocess import Popen


def ensure_file (path):
    """
        Looks for  file at provided path, creates it if it does not exist.
        Returns the file.
    """
    rfile = None    
    if not os.path.exists(path) and os.path.isfile(path) :
        rfile = open(path,"w+");
        print("ensuring file : %s " % path)

    print("file ensured : %s " % path)
    return rfile


command = '/usr/bin/avahi-announce-alias'
alias_pid_path = "/tmp/avahi-aliases.pid"
alias_file_path = "/etc/avahi/aliases"

alias_file = open(alias_file_path)
if not os.path.exists(alias_pid_path) :
    open(alias_pid_path,"w").close()

alias_pid = open(alias_pid_path,"r")


for line in alias_pid :
    txt = line.strip('\n')
    if len(txt) > 0 :
        print("kill %s" % txt )
        os.system("kill %s" % txt)          
alias_pid.close()
alias_pid = open(alias_pid_path,"w+")

for line in alias_file :
    txt = line.strip('\n')
    if len(txt) > 0 :
        print("publishing : << %s >>" % txt)
        process = Popen([command, txt])
        alias_pid.write("%s\n" % str(process.pid))    
alias_pid.close()

print("done")

Il est nullement censé être le summum de la programmation de python, donc ne hésitez pas à apporter les améliorations que vous voyez en forme.

Utilisation

Si notre nom d'hôte était « serveur » et le nom d'hôte avahi-était « serveur.local », alors nous pourrions remplir le fichier texte /etc/avahi/aliases avec vos noms d'hôtes supplémentaires comme ceci:

deluge.server.local
username.server.local
accounts.server.local
something-else.server.local
another.hostname.home

(mais vraiment, je suis sûr que vous pourriez avoir un nom d'hôte là-bas vous offrir assuriez qu'il n'existait pas déjà sur le réseau, ce qui est la raison pour laquelle je crée juste « sous-domaines » du nom d'hôte Avahi normale)

Ensuite, nous courons:

sudo avahi-publish-aliases

Ma principale raison de cette mise en place est de faciliter la simulation plus facile du développement site django & drupal sur mon ordinateur portable.

Avertissements

Ma seule déception est que la mise en œuvre de fenêtres Bonjour / Avahi ne supporte pas les alias que cette exécution annonce, il ne verra le nom d'hôte principal de Avahi normalement annoncé (c.-à-serveur.local dans notre exemple ci-dessus).

Answer 3

On dirait airtonix mis en œuvre et ce fait disponible à https://github.com/airtonix/avahi- alias

est à https://github.com / hmalphettes / avahi-alias

Answer 4

Vous pouvez enregistrer des documents supplémentaires en utilisant l'API Avahi. Cet exemple sur le wiki Avahi montre comment publier des enregistrements supplémentaires CNAME (alias) en Python .

Answer 5

Je sais que c'est vieux, mais une meilleure solution serait Dnsmasq .

Ceci peut être accompli simplement ... par les arguments / config ...

  

Retour ipaddr pour tous les hôtes dans des domaines spécifiés.

     

-A, --address=/<domain>/<ipaddr>