GraphQL et Nautobot

GraphQL est un langage de requête et un environnement d’exécution côté serveur pour les API (Application Programming Interface) qui s’attache à fournir aux clients les données qui ont été demandées. Utilisé à la place de REST, GraphQL permet aux développeurs de créer des requêtes qui extraient les données de plusieurs sources à l’aide d’une seule requête API. Les requêtes GraphQL renvoient toujours des résultats prévisibles. Alors que les API REST typiques nécessitent un chargement à partir de plusieurs URL, les API GraphQL obtiennent toutes les données dont l’application a besoin en une seule demande. De plus, avec GraphQL, les équipes chargées de la maintenance des API peuvent librement ajouter ou retirer des champs sans perturber les requêtes existantes.

GraphQL a été développé par Facebook, qui a commencé à l’utiliser pour les applications mobiles en 2012. La spécification de GraphQL est devenue Open Source en 2015. Elle est désormais supervisée par la GraphQL Foundation.

Un service GraphQL est créé en définissant des types et des champs sur ces types, puis en fournissant des fonctions pour chaque champ sur chaque type. Par exemple, un service GraphQL qui indique qui est l’utilisateur connecté (me) ainsi que le nom de cet utilisateur peut ressembler à ceci :

type Query {
  me: User
}
 
type User {
  id: ID
  name: String
}

Avec des fonctions pour chaque champ sur chaque type :

function Query_me(request) {
  return request.auth.user;
}
 
function User_name(user) {
  return user.getName();
}

Une fois qu’un service GraphQL est en cours d’exécution (généralement à une URL sur un service Web), il peut recevoir des requêtes GraphQL à valider et à exécuter. Le service vérifie d’abord la requête pour s’assurer qu’elle se réfère uniquement aux types et champs définis, puis exécute les fonctions fournies pour produire un résultat.

Par exemple, la requête :

{
  me {
    name
  }
}

Pourrait produire le résultat JSON suivant :

{
  "me": {
    "name": "Luke Skywalker"
  }
}

Nautobot prend en charge une interface GraphQL en lecture seule qui peut être utilisée pour interroger la plupart des informations présentes dans la base de données. L’interface GraphQL est disponible via graphql/ pour l’explorer manuellement et GraphQL peut être interrogé en tant qu’API via le point de terminaison api/graphql/. Actuellement, la prise en charge de GraphQL est limitée à query, d’autres types d’opérations comme mutations et subscriptions ne sont pas prises en charge.

L’interface GraphQL peut être utilisée pour interroger plusieurs tables à la fois dans une seule requête. Dans GraphQL, seules les informations demandées seront renvoyées. Dans l’exemple ci-dessous, cette requête renverra le nom de toutes les interfaces attachées à l’équipement nyc-sw01, ainsi que de toutes ip_addresses attachées à ces interfaces.

query {
  devices(name: "nyc-sw01") {
    name
    interfaces {
      name
      ip_addresses {
        address
      }
    }
  }
}

{
  "data": {
    "devices": [
      {
        "name": "nyc-sw01",
        "interfaces": [
          {
            "name": "xe-0/0/0",
            "ip_addresses": [
              {
                "address": "10.52.0.1/30"
              }
            ]
          },
          {
            "name": "xe-0/0/1",
            "ip_addresses": []
          }
        ]
      }
    ]
  }
}

Les graphiques sont des outils puissants pour modéliser de nombreux phénomènes du monde réel, car ils ressemblent à nos schémas mentaux naturels. Avec GraphQL, on peut modéliser un domaine d’activité sous forme de graphique en définissant un schéma. Dans ce schéma, on définit différents types de nœuds et comment ils se connectent et se rapportent les uns aux autres (un peu comme dans la programmation orientée objet).

Le schéma GraphQL pour Nautobot peut être visualisé sous la forme d’une carte mentale grâce à un outil comme GraphQL Voyager.

Que ce soit avec Ansible ou Python, l’interrogation GraphQL peut passer par l’utilisation d’un template Jinja2 afin de générer la requête. Pour ce qui est d’Ansible, le module uri permet d’envoyer la requête au point de terminaison api/graphql/ avec le champ body contenant la query.