Synchroniser des objets RIPE, ARIN et APNIC avec un module Ansible sur mesure

Vincent Bernat

L’In­ter­net est di­visé en cinq re­gistres In­ter­net ré­gio­naux : AFRINIC, ARIN, APNIC, LACNIC et RIPE. Cha­cun de ces RIR gère un re­gistre de rou­tage In­ter­net. Un tel IRR per­met de pu­blier des in­for­ma­tions sur le rou­tage des res­sources In­ter­net1. Les opé­ra­teurs l’uti­lisent pour dé­ter­mi­ner le pro­prié­taire d’une adresse IP et pour construire et main­te­nir des filtres de rou­tage. Pour que vos routes soient lar­ge­ment ac­cep­tées, il est im­por­tant de te­nir à jour les pré­fixes que vous an­non­cez dans un IRR.

Il existe deux ou­tils cou­rants pour in­ter­ro­ger cette base de don­nées : whois et bgpq4. Le pre­mier vous per­met d’ef­fec­tuer une re­quête avec le pro­to­cole WHOIS :

$ whois -h whois.ripe.net -- '-BrG 2a0a:e805:400::/40'
[…]
inet6num:       2a0a:e805:400::/40
netname:        FR-BLADE-CUSTOMERS-DE
country:        DE
geoloc:         50.1109 8.6821
admin-c:        BN2763-RIPE
tech-c:         BN2763-RIPE
status:         ASSIGNED
mnt-by:         fr-blade-1-mnt
remarks:        synced with cmdb
created:        2020-05-19T08:04:58Z
last-modified:  2020-05-19T08:04:58Z
source:         RIPE

route6:         2a0a:e805:400::/40
descr:          Blade IPv6 - AMS1
origin:         AS64476
mnt-by:         fr-blade-1-mnt
remarks:        synced with cmdb
created:        2019-10-01T08:19:34Z
last-modified:  2020-05-19T08:05:00Z
source:         RIPE

Le se­cond per­met de construire des filtres de rou­tage en uti­li­sant les in­for­ma­tions conte­nues dans la base de don­nées IRR :

$ bgpq4 -6 -S RIPE -b AS64476
NN = [
    2a0a:e805::/40,
    2a0a:e805:100::/40,
    2a0a:e805:300::/40,
    2a0a:e805:400::/40,
    2a0a:e805:500::/40
];

Il n’y a pas de mo­dule dis­po­nible sur An­sible Ga­laxy pour gé­rer ces ob­jets. Chaque IRR a dif­fé­rentes fa­çons d’être mis à jour. Cer­tains RIR pro­posent une API, mais d’autres non. Si l’on se li­mite au RIPE, à l’ARIN et à l’APNIC, la seule mé­thode com­mune de mise à jour des ob­jets est la mise à jour par cour­rier élec­tro­nique, au­then­ti­fiée par un mot de passe ou une si­gna­ture PGP2. Écri­vons un mo­dule An­sible à cet effet !

Note

Je vous re­com­mande de lire « Écrire un mo­dule An­sible sur me­sure » en in­tro­duc­tion, ainsi que « Syn­chro­ni­ser des tables MySQL » pour un pre­mier exemple plus di­dactique.

Code#

Le mo­dule prend une liste d’ob­jets RPSL à syn­chro­ni­ser et ren­voie le contenu d’un cour­rier élec­tro­nique pour mise à jour si un chan­ge­ment est né­cessaire :

- name: prepare RIPE objects
  irr_sync:
    irr: RIPE
    mntner: fr-blade-1-mnt
    source: whois-ripe.txt
  register: irr

Prérequis#

Le fi­chier source doit être un en­semble d’ob­jets à syn­chro­ni­ser en uti­li­sant le lan­gage RPSL. Il s’agi­rait du même contenu que ce­lui que vous en­ver­riez ma­nuel­le­ment par cour­rier élec­tro­nique. Tous les ob­jets doivent être gé­rés par le même main­te­neur, éga­le­ment fourni en pa­ramètre.

La si­gna­ture3 et l’en­voi du ré­sul­tat ne re­lèvent pas de la res­pon­sa­bi­lité de ce mo­dule. Vous avez be­soin de deux tâches sup­plé­men­taires à cette fin :

- name: sign RIPE objects
  shell:
    cmd: gpg --batch --local-user noc@example.com --clearsign
    stdin: "{{ irr.objects }}"
  register: signed
  check_mode: false
  changed_when: false

- name: update RIPE objects by email
  mail:
    subject: "NEW: update for RIPE"
    from: noc@example.com
    to: "auto-dbm@ripe.net"
    cc: noc@example.com
    host: smtp.example.com
    port: 25
    charset: us-ascii
    body: "{{ signed.stdout }}"

Vous de­vez aussi au­to­ri­ser la clé PGP uti­li­sée pour si­gner les mises à jour en créant un ob­jet key-cert et en l’ajou­tant comme mé­thode d’au­then­ti­fi­ca­tion pour l’ob­jet mntner cor­res­pondant :

key-cert:  PGPKEY-A791AAAB
certif:    -----BEGIN PGP PUBLIC KEY BLOCK-----
certif:
certif:    mQGNBF8TLY8BDADEwP3a6/vRhEERBIaPUAFnr23zKCNt5YhWRZyt50mKq1RmQBBY
[…]
certif:    -----END PGP PUBLIC KEY BLOCK-----
mnt-by:    fr-blade-1-mnt
source:    RIPE

mntner:    fr-blade-1-mnt
[…]
auth:      PGPKEY-A791AAAB
mnt-by:    fr-blade-1-mnt
source:    RIPE

Définition du module#

En se ba­sant sur le sque­lette pré­senté dans l’ar­ticle pré­cé­dent, nous dé­fi­nis­sons le module :

module_args = dict(
    irr=dict(type='str', required=True),
    mntner=dict(type='str', required=True),
    source=dict(type='path', required=True),
)

result = dict(
    changed=False,
)

module = AnsibleModule(
    argument_spec=module_args,
    supports_check_mode=True
)

Obtenir les objets existants#

Pour ré­cu­pé­rer les ob­jets exis­tants, la com­mande whois re­cherche tous les ob­jets at­ta­chés au main­te­neur fourni en pa­ra­mètre du module.

# Per-IRR variations:
# - whois server
whois = {
    'ARIN': 'rr.arin.net',
    'RIPE': 'whois.ripe.net',
    'APNIC': 'whois.apnic.net'
}
# - whois options
options = {
    'ARIN': ['-r'],
    'RIPE': ['-BrG'],
    'APNIC': ['-BrG']
}
# - objects excluded from synchronization
excluded = ["domain"]
if irr == "ARIN":
    # ARIN does not return these objects
    excluded.extend([
        "key-cert",
        "mntner",
    ])

# Grab existing objects
args = ["-h", whois[irr],
        "-s", irr,
        *options[irr],
        "-i", "mnt-by",
        module.params['mntner']]
proc = subprocess.run(["whois", *args], capture_output=True)
if proc.returncode != 0:
    raise AnsibleError(
        f"unable to query whois: {args}")
output = proc.stdout.decode('ascii')
got = extract(output, excluded)

La pre­mière par­tie du code in­tro­duit des constantes spé­ci­fiques à chaque IRR : le ser­veur à in­ter­ro­ger, les op­tions à four­nir à la com­mande whois et les ob­jets à ex­clure de la syn­chro­ni­sa­tion. La se­conde par­tie in­voque la com­mande whois qui ré­cu­père tous les ob­jets dont le champ mnt-by cor­res­pond au main­te­neur fourni. Voici un exemple de sortie :

$ whois -h whois.ripe.net -- '-s RIPE -BrG -i mnt-by fr-blade-1-mnt'
[…]

inet6num:       2a0a:e805:300::/40
netname:        FR-BLADE-CUSTOMERS-FR
country:        FR
geoloc:         48.8566 2.3522
admin-c:        BN2763-RIPE
tech-c:         BN2763-RIPE
status:         ASSIGNED
mnt-by:         fr-blade-1-mnt
remarks:        synced with cmdb
created:        2020-05-19T08:04:59Z
last-modified:  2020-05-19T08:04:59Z
source:         RIPE

[…]

route6:         2a0a:e805:300::/40
descr:          Blade IPv6 - PA1
origin:         AS64476
mnt-by:         fr-blade-1-mnt
remarks:        synced with cmdb
created:        2019-10-01T08:19:34Z
last-modified:  2020-05-19T08:05:00Z
source:         RIPE

[…]

Le ré­sul­tat est trans­mis à la fonc­tion extract(). Elle ana­lyse et nor­ma­lise les ré­sul­tats dans un dic­tion­naire qui met en cor­res­pon­dance les noms d’ob­jets et les ob­jets. Nous sto­ckons le ré­sul­tat dans la va­riable got.

def extract(raw, excluded):
    """Extract objects."""
    # First step, remove comments and unwanted lines
    objects = "\n".join([obj
                         for obj in raw.split("\n")
                         if not obj.startswith((
                                 "#",
                                 "%",
                         ))])
    # Second step, split objects
    objects = [RPSLObject(obj.strip())
               for obj in re.split(r"\n\n+", objects)
               if obj.strip()
               and not obj.startswith(
                   tuple(f"{x}:" for x in excluded))]
    # Last step, put objects in a dict
    objects = {repr(obj): obj
               for obj in objects}
    return objects

RPSLObject() est la classe qui per­met de nor­ma­li­ser et com­pa­rer les ob­jets. Re­gar­dez le code du mo­dule pour plus de détails.

>>> output="""
... inet6num:       2a0a:e805:300::/40
... […]
... """
>>> pprint({k: str(v) for k,v in extract(output, excluded=[])})
{'<Object:inet6num:2a0a:e805:300::/40>':
   'inet6num:       2a0a:e805:300::/40\n'
   'netname:        FR-BLADE-CUSTOMERS-FR\n'
   'country:        FR\n'
   'geoloc:         48.8566 2.3522\n'
   'admin-c:        BN2763-RIPE\n'
   'tech-c:         BN2763-RIPE\n'
   'status:         ASSIGNED\n'
   'mnt-by:         fr-blade-1-mnt\n'
   'remarks:        synced with cmdb\n'
   'source:         RIPE',
 '<Object:route6:2a0a:e805:300::/40>':
   'route6:         2a0a:e805:300::/40\n'
   'descr:          Blade IPv6 - PA1\n'
   'origin:         AS64476\n'
   'mnt-by:         fr-blade-1-mnt\n'
   'remarks:        synced with cmdb\n'
   'source:         RIPE'}

Comparer avec les objets souhaités#

Construi­sons main­te­nant le dic­tion­naire wanted en réuti­li­sant la fonc­tion extract() :

with open(module.params['source']) as f:
    source = f.read()
wanted = extract(source, excluded)

L’étape sui­vante est de com­pa­rer got et wanted pour construire les dif­férences :

if got != wanted:
    result['changed'] = True
    if module._diff:
        result['diff'] = [
            dict(before_header=k,
                 after_header=k,
                 before=str(got.get(k, "")),
                 after=str(wanted.get(k, "")))
            for k in set((*wanted.keys(), *got.keys()))
            if k not in wanted or k not in got or wanted[k] != got[k]]

Retourner les mises à jour#

Le mo­dule n’a pas d’ef­fet de bord. S’il y a une dif­fé­rence, nous re­tour­nons les mises à jour à en­voyer par cour­rier élec­tro­nique. Nous choi­sis­sons d’in­clure tous les ob­jets sou­hai­tés dans les mises à jour (conte­nus dans la va­riable source) et de lais­ser l’IRR igno­rer les ob­jets non mo­di­fiés. Nous ajou­tons éga­le­ment les ob­jets à sup­pri­mer en ajou­tant un at­tri­but delete: à cha­cun d’entre eux.

# We send all source objects and deleted objects.
deleted_mark = f"{'delete:':16}deleted by CMDB"
deleted = "\n\n".join([f"{got[k].raw}\n{deleted_mark}"
                       for k in got
                       if k not in wanted])
result['objects'] = f"{source}\n\n{deleted}"

module.exit_json(**result)

Le code com­plet est dis­po­nible sur GitHub. Le mo­dule prend en charge les op­tions --diff et --check. Il ne ren­voie rien si au­cun chan­ge­ment n’est dé­tecté. Il peut fonc­tion­ner avec l’APNIC, le RIPE et l’ARIN. Il n’est pas par­fait : il peut ne pas dé­tec­ter cer­tains chan­ge­ments4, il n’est pas ca­pable de mo­di­fier des ob­jets n’ap­par­te­nant pas au main­te­neur fourni5 et cer­tains at­tri­buts re­fusent les mises à jour, ce qui né­ces­site de sup­pri­mer et de re­créer ma­nuel­le­ment l’ob­jet6. Ce­pen­dant, ce mo­dule de­vrait au­to­ma­ti­ser 95% de vos besoins.