Mapper les instructions de configuration de Junos OS à JSON
Une configuration d’un équipement exécutant Junos OS est stockée sous la forme d’une hiérarchie d’instructions. La hiérarchie des instructions de configuration comporte deux types d’instructions :
instruction de conteneur : instructions contenant d’autres instructions
instructions de branche : instructions qui ne contiennent pas d’autres instructions
L’ensemble des instructions de conteneur et de branche forme la hiérarchie de configuration.
La hiérarchie de configuration peut être représentée à l’aide de JSON (JavaScript Object Notation) en plus du texte ASCII au format, des éléments XML Junos et des commandes de mode set de configuration. À partir de Junos OS Version 14.2, vous pouvez afficher la configuration d’un équipement exécutant Junos OS au format JSON en exécutant la show configuration | display json commande dans l’interface de ligne de commande. En outre, à partir de Junos OS Version 16.1, vous pouvez charger les données de configuration au format JSON sur l’équipement.
À partir de Junos OS Version 16.1, les équipements exécutant Junos OS émettent des données de configuration au format JSON à l’aide d’une nouvelle implémentation par défaut pour la sérialisation. Vous pouvez configurer explicitement le nouveau par défaut, ietfou revenir à la valeur par défaut précédente, verboseen configurant l’instruction appropriée au niveau de la [edit system export-format json] hiérarchie. Vous pouvez configurer l’instruction verbose à partir de Junos OS Version 16.1R1, même si elle n’est pas exposée dans l’interface de ligne de commande Junos OS avant une version ultérieure.
À partir des versions 16.1R4, 16.2R2 et 17.1R1 de Junos OS, les entiers des données de configuration Junos OS émises au format JSON ne sont pas joints entre guillemets. Dans les versions antérieures, les entiers des données de configuration JSON sont traités comme des chaînes et joints entre guillemets.
Les sections suivantes décrivent le mappage entre le texte ASCII au format formaté et le format par défaut utilisé pour les instructions de configuration Junos OS dans JSON :
Mappage des niveaux hiérarchiques et des instructions de conteneur
La hiérarchie de configuration de Junos OS est représentée dans JSON par un objet JSON avec un seul membre de niveau supérieur, ou paire nom/valeur, avec le nom du champ et "configuration" une valeur contenant un objet JSON représentant l’ensemble de la configuration. Le configuration membre correspond au niveau hiérarchique du [edit] mode de configuration CLI. La plupart des instructions aux niveaux suivants de la hiérarchie de configuration sont des instructions de conteneur.
Dans JSON, chaque niveau hiérarchique ou instruction de conteneur de Junos OS est membre de son objet parent. Le membre, ou paire nom/valeur, porte un nom de champ correspondant au nom de la hiérarchie ou du conteneur. Sa valeur est un objet JSON qui contient des membres représentant les conteneurs enfants et des instructions de branche à ce niveau hiérarchique. L’objet peut également contenir un membre qui contient la liste des attributs, le cas échéant, associés à cette hiérarchie.
L’exemple suivant montre le mappage entre le texte ASCII au format et JSON pour deux instructions au niveau supérieur de la hiérarchie de configuration :
Instructions de configuration CLI
system {
login {
...child statements...
}
}
protocols {
ospf {
...child statements...
}
}
Syntaxe JSON
{
"configuration" : {
"system" : {
"login" : {
...JSON configuration data...
}
}
"protocols" : {
"ospf" : {
...JSON configuration data...
}
}
}
}
Mappage pour les objets ayant un identifiant
À certains niveaux hiérarchiques, le même type d’objet de configuration peut se produire plusieurs fois. Chaque instance de l’objet dispose d’un identifiant unique pour le distinguer des autres instances. Dans la notation CLI, l’instruction parente d’un tel objet peut se composer d’un mot-clé et d’un identifiant ou simplement d’un identifiant.
keyword identifier {
… configuration statements for individual characteristics …
}
keywordest une chaîne fixe qui indique le type d’objet en cours de définition et identifier est un nom unique pour une instance de ce type. Dans l’exemple suivant, user il s’agit d’un mot-clé.username
user username {
/* child statements */
}
Dans JSON, toutes les instances d’un objet de configuration sont contenues dans une paire nom/valeur unique dans laquelle le nom du champ correspond généralement à la keyword chaîne, et la valeur est un ensemble d’objets JSON, chacun étant une instance de l’objet de configuration. La syntaxe JSON diffère de l’interface CLI dans son traitement de l’identificateur. Dans JSON, chaque instance de l’objet de configuration utilise une paire nom/valeur pour l’identificateur, où le nom du champ distingue ces données comme identificateur, et la valeur est l’identificateur unique réel de l’objet. Le plus souvent, le nom du champ est juste name. Certains objets ont plusieurs identifiants et peuvent utiliser un nom de champ autre que name. Les données JSON qui spécifient un identifiant sont toujours répertoriées en premier dans l’objet correspondant, mais après toute liste d’attributs incluse pour cet objet.
{
"keyword" : [
{
"@" : {
"comment" : "comment"
},
"name" : "identifier",
JSON data for individual characteristics
},
{
"name" : "identifier",
JSON data for individual characteristics
}
]
}
Junos OS se réserve le préfixe junos- pour les identifiants des groupes de configuration définis au sein du groupe de junos-defaults configuration. Les identifiants définis par l’utilisateur ne peuvent pas commencer par la chaîne junos-.
La configuration de la plupart des objets dotés d’identifiants comprend des instructions de branche supplémentaires, qui représentent d’autres caractéristiques de l’objet. Par exemple, chaque groupe BGP configuré au niveau de la [edit protocols bgp group] hiérarchie a un nom associé (l’identificateur) et peut avoir des instructions de branche pour d’autres caractéristiques, telles que le type, le numéro de système autonome d’appairage (AS) et l’adresse de voisinage. Pour plus d’informations sur le mappage JSON pour les instructions de branche, consultez Mappage pour les instructions de branche à valeur unique et à formulaire fixe.
L’exemple suivant illustre le mappage du texte ASCII au format JSON pour les instructions de configuration qui définissent deux groupes BGP nommés G1 et G2. Dans la syntaxe JSON, la group valeur du membre est un tableau qui contient un objet JSON distinct pour chaque groupe BGP.
Instructions de configuration CLI
protocols {
bgp {
group G1 {
type external;
peer-as 64501;
neighbor 10.0.0.1;
}
group G2 {
type external;
peer-as 64502;
neighbor 10.0.10.1;
}
}
}
Syntaxe JSON
{
"configuration" : {
"protocols" : {
"bgp" : {
"group" : [
{
"name" : "G1",
"type" : "external",
"peer-as" : "64501",
"neighbor" : [
{
"name" : "10.0.0.1"
}
]
},
{
"name" : "G2",
"type" : "external",
"peer-as" : "64502",
"neighbor" : [
{
"name" : "10.0.10.1"
}
]
}
]
}
}
}
}
Mappage pour les instructions de branche à valeur unique et à formulaire fixe
Une instruction leaf est une instruction de configuration CLI qui ne contient aucune autre instruction. La plupart des instructions de branche définissent une valeur pour une caractéristique d’un objet de configuration et présentent le formulaire suivant :
keyword value;
Les instructions de branche de Junos OS sont mappées à des paires nom/valeur au format JSON. En général, le nom du champ est le même que la keyword chaîne, et la valeur est la même que la value chaîne.
L’exemple suivant montre le mappage JSON pour deux instructions de branche contenant un mot-clé et une valeur : l’instruction message au niveau de la [edit system login] hiérarchie et l’instruction preference au niveau de la [edit protocols ospf] hiérarchie .
Instructions de configuration CLI
system {
login {
message "Authorized users only.";
... other statements under login ...
}
}
protocols {
ospf {
preference 15;
... other statements under ospf ...
}
}
Syntaxe JSON
{
"configuration" : {
"system" : {
"login" : {
"message" : "Authorized users only.",
... JSON data for other statements under login ...
}
},
"protocols" : {
"ospf" : {
"preference" : "15",
... JSON data for other statements under ospf ...
}
}
}
}
Certaines instructions de branche se composent uniquement d’un mot-clé à forme fixe, sans valeur de forme variable associée. Junos OS représente ces instructions dans JSON en définissant la valeur dans la paire nom/valeur sur [null]. L’exemple suivant montre le mappage JSON de l’instruction disable au niveau de la [edit forwarding-options sampling] hiérarchie.
Instructions de configuration CLI
forwarding-options {
sampling {
disable;
}
}
Syntaxe JSON
{
"configuration" : {
"forwarding-options" : {
"sampling" : {
"disable" : [null]
}
}
}
}
Mappage pour les instructions de branche avec plusieurs valeurs
Certaines instructions de branche de Junos OS acceptent plusieurs valeurs, qui peuvent être définies par l’utilisateur ou tirées d’un ensemble de valeurs prédéfinies. La notation CLI utilise des supports carrés pour joindre toutes les valeurs dans une seule instruction, comme dans l’exemple suivant :
keyword [ value1 value2 value3 ...];
Comme indiqué dans Le mappage d’instructions de branche à valeur unique et à formulaire fixe, les instructions de branche sont mappées aux paires de nom/valeur dans JSON, où le nom du champ est le même que la keyword chaîne. Pour représenter plusieurs valeurs, la partie valeur des données JSON utilise un ensemble de chaînes séparées par des virgules.
L’exemple suivant montre le mappage JSON pour une déclaration CLI avec plusieurs valeurs définies par l’utilisateur. L’instruction import importe deux stratégies de routage définies ailleurs dans la configuration. Le texte ASCII au format utilise une liste de valeurs séparées par l’espace, tandis que les données JSON utilisent un tableau avec une liste de chaînes séparées par des virgules.
Instructions de configuration CLI
protocols {
bgp {
group 23 {
import [ policy1 policy2 ];
}
}
}
Syntaxe JSON
{
"configuration" : {
"protocols" : {
"bgp" : {
"group" : [
{
"name" : "23",
"import" : ["policy1", "policy2"]
}
]
}
}
}
}
L’exemple suivant montre le mappage JSON pour une instruction CLI avec plusieurs valeurs prédéfinies. L’instruction permissions accorde trois autorisations prédéfinies aux membres de la user-accounts classe de connexion.
Instructions de configuration CLI
system {
login {
class user-accounts {
permissions [ admin configure control ];
}
}
}
Syntaxe JSON
{
"configuration" : {
"system" : {
"login" : {
"class" : [
{
"name" : "user-accounts",
"permissions" : ["admin", "configure", "control"]
}
]
}
}
}
}
Mappage pour plusieurs options sur une ou plusieurs lignes
Pour certains objets de configuration de Junos OS, la syntaxe CLI standard place plusieurs options sur une seule ligne, généralement pour une lisibilité et une concision accrues. Dans la plupart des cas, la première option identifie l’objet et ne comporte pas de mots-clés, mais les options ultérieures sont des mots-clés et des valeurs associés.
Dans JSON, le même objet de configuration mappe à une paire nom/valeur. Le nom du champ est le même que le nom de l’objet, et la valeur est un objet JSON contenant les options, qui sont représentées par des paires nom/valeur. Si la première option ne contient aucun mot-clé dans l’instruction CLI, le mappage JSON attribue un nom, qui est équivalent au nom d’option défini dans le schéma et utilisé pour le nom de balise XML Junos correspondant.
L’exemple suivant illustre le mappage JSON pour une instruction de configuration CLI avec plusieurs options sur une seule ligne. La représentation JSON de l’instruction [edit system backup-router] utilise des paires nom/valeur pour les deux options et attribue le nom address de champ de la première option (10.0.0.1), qui ne comporte aucun mot-clé CLI.
Instructions de configuration CLI
system {
backup-router 10.0.0.1 destination 10.0.0.2/32;
}
Syntaxe JSON
{
"configuration" : {
"system" : {
"backup-router" : {
"address" : "10.0.0.1",
"destination" : ["10.0.0.2/32"]
}
}
}
}
La syntaxe de certains objets de configuration comprend plusieurs lignes à options multiples. Dans JSON, l’objet de configuration est mappé à une paire nom/valeur, comme dans le cas précédent. Le nom du champ est le même que le nom de l’objet, et la valeur est un objet JSON contenant les options, qui sont représentées par des paires nom/valeur. Pour chaque option, le nom du champ est le même que le nom de l’option, et la valeur est une structure de données JSON qui représente de manière appropriée les données de configuration pour cette option. Lorsqu’une option utilise le même mot-clé mais s’étend sur plusieurs lignes, la représentation JSON combine les options en une paire nom/valeur unique. Dans ce cas, la valeur est un tableau d’objets JSON dans lequel chaque option est mappée à un objet distinct.
L’exemple suivant montre le mappage JSON de l’instruction traceoptions au niveau de la [edit protocols isis] hiérarchie. L’énoncé traceoptions contient trois déclarations d’enfant, chacune comportant plusieurs options. La notation CLI affiche les options individuelles flag sur des lignes distinctes, mais la représentation JSON combine les flag détails en une paire nom/valeur unique. La valeur est un tableau d’objets où chaque objet contient les détails d’un indicateur.
Instructions de configuration CLI
protocols {
isis {
traceoptions {
file trace-file size 3m files 10 world-readable;
flag route detail;
flag state receive;
}
}
}
Syntaxe JSON
{
"configuration" : {
"protocols" : {
"isis" : {
"traceoptions" : {
"file" : {
"filename" : "isis-trace-file",
"size" : "3m",
"files" : 10,
"world-readable" : [null]
},
"flag" : [
{
"name" : "route",
"detail" : [null]
},
{
"name" : "state",
"receive" : [null]
}
]
}
}
}
}
}
Mappage des attributs
La hiérarchie de configuration de Junos OS peut contenir des balises qui modifient une hiérarchie ou une instruction. Par exemple, si vous désactivez deactivate une instruction dans la configuration, la inactive: balise est prépendée sur l’élément de la configuration pour indiquer cette propriété. L’API XML Junos représente cette propriété sous forme d’attribut dans la balise d’ouverture de l’élément XML.
La représentation JSON de la configuration de Junos OS utilise des annotations de métadonnées pour représenter ces propriétés. Les annotations des métadonnées sont encodées en tant que membres d’un objet JSON unique et incluent le symbole « @ » en tant que ou dans le nom.
L’objet de métadonnées représentant la liste d’attributs d’une instruction de conteneur est ajouté en tant que nouveau membre de cet objet. L’objet de métadonnées est placé directement à l’intérieur de l’objet du conteneur qu’il modifie et utilise un seul symbole « @ » comme nom de membre. L’objet de métadonnées représentant la liste d’attributs d’une instruction de branche est ajouté sous la forme d’une paire nom/valeur fraternel placée directement après l’instruction qu’elle modifie, avec un nom de membre qui correspond à la dissociation du symbole « @ » et du nom de la déclaration. Dans les deux cas, la valeur de l’objet de métadonnées est un objet contenant des paires nom/valeur qui décrivent chacun des attributs associés à cet énoncé de conteneur ou de branche.
{
"container" : {
"@" : {
"attribute-name" : attribute-value,
"attribute-name" : attribute-value
},
"statement-name" : "statement-value",
"@statement-name" : {
"attribute-name" : attribute-value,
"attribute-name" : attribute-value
}
}
}
Dans les exemples suivants, la [edit commit] hiérarchie et l’énoncé persist-groups-inheritance ont été désactivés. Dans l’interface de ligne de commande, les instructions sont précédées de la inactive: balise. La représentation XML de Junos inclut l’attribut inactive="inactive" dans chacune des balises d’ouverture de ces éléments. Le mappage JSON stocke les attributs dans une liste d’attributs. La liste des attributs de la [edit commit] hiérarchie est indiquée par « @ », car il s’agit d’une déclaration de conteneur. La liste d’attributs de l’instruction est indiquée à l’aide persist-groups-inheritance de « @persist-groups-héritage », car il s’agit d’une déclaration de branche.
Instructions de configuration CLI
system {
inactive: commit {
inactive: persist-groups-inheritance;
}
}
Syntaxe XML
<configuration>
<system>
<commit inactive="inactive">
<persist-groups-inheritance inactive="inactive"/>
</commit>
</system>
</configuration>
Syntaxe JSON
{
"configuration" : {
"system" : {
"commit" : {
"@" : {
"inactive" : true
},
"persist-groups-inheritance" : [null],
"@persist-groups-inheritance" : {
"inactive" : true
}
}
}
}
}
La liste d’attributs d’une instance spécifique d’un objet est similaire à celle d’un conteneur en ce qu’il s’agit d’une paire nom/valeur où le nom du champ est un symbole « @ » unique, et la valeur est un objet contenant des paires nom/valeur qui décrivent chacun des attributs. La liste des attributs est jointe à l’objet JSON qui identifie cette instance et est le premier membre de l’objet, suivie de l’identificateur de l’objet.
{
"keyword" : [
{
"@" : {
"attribute-name" : attribute-value
},
"name" : "identifier",
...JSON data for individual characteristics...
},
/* additional objects */
]
}
Dans l’exemple suivant, l’interface ge-0/0/0 est protégée. Dans l’interface de ligne de commande, l’objet est précédé de la protect: balise. La représentation XML de Junos inclut l’attribut protect="protect" dans la balise d’ouverture de cet objet. Le mappage JSON stocke l’attribut "protect" : true dans une liste d’attributs incluse dans l’objet JSON identifiant cette interface spécifique.
Instructions de configuration CLI
protect: ge-0/0/0 {
unit 0 {
family inet {
address 198.51.100.1/24;
}
}
}
Syntaxe XML
<configuration>
<interfaces>
<interface protect="protect">
<name>ge-0/0/0</name>
<unit>
<name>0</name>
<family>
<inet>
<address>
<name>198.51.100.1/24</name>
</address>
</inet>
</family>
</unit>
</interface>
</interfaces>
</configuration>
Syntaxe JSON
{
"configuration" : {
"interfaces" : {
"interface" : [
{
"@" : {
"protect" : true
},
"name" : "ge-0/0/0",
"unit" : [
{
"name" : 0,
"family" : {
"inet" : {
"address" : [
{
"name" : "198.51.100.1/24"
}
]
}
}
}
]
}
]
}
}
}
Mappage pour les commentaires de configuration
Une configuration Junos OS peut inclure des commentaires décrivant des instructions dans la configuration. Les données de configuration formatées à l’aide de texte ASCII ou d’éléments XML Junos affichent des commentaires sur la ligne précédant l’instruction que le commentaire modifie. Au format XML Junos, la chaîne de commentaires est incluse dans un <junos:comment> élément.
Les commentaires sont indiqués à l’aide de l’une des deux limites : les chaînes /* appariées et */ en joignant le commentaire, ou le # caractère précédant le commentaire. Vous pouvez utiliser le délimitateur dans la chaîne de commentaires lorsque vous insérez des commentaires dans la configuration. Si vous omettez le délimitateur, Junos OS insère /* automatiquement et */.
Junos OS préserve tout espace blanc inclus dans le commentaire.
Les données de configuration de Junos OS formatées à l’aide de JSON mappent un commentaire à une paire nom/valeur stockée en tant qu’attribut de l’instruction qu’elle modifie. Le nom du champ est défini sur "comment", et la valeur est la chaîne de texte de commentaire. La chaîne de texte du commentaire peut inclure l’une des deux délimitatrices indiquant un commentaire. Si vous omettez le délimitateur de la chaîne de texte des commentaires lorsque vous chargez les données de configuration JSON, Junos OS ajoute automatiquement les /* messages et */ délimitateurs au commentaire. Vous pouvez également créer des commentaires multiline dans les données de configuration JSON en insérant le caractère newline (\n) dans la chaîne de commentaires.
L’exemple suivant illustre la configuration ASCII au format et la syntaxe JSON correspondante pour trois commentaires. L’exemple associe un commentaire à une hiérarchie, un autre commentaire à un objet qui a un identifiant, et un troisième commentaire avec une déclaration de branche.
Instructions de configuration CLI
protocols {
/* New backbone area */
ospf {
area 0.0.0.0 {
/* From jnpr1
to jnpr2 */
interface so-0/0/0.0 {
# set by admin
hello-interval 5;
}
}
}
}
Syntaxe JSON
{
"configuration" : {
"protocols" : {
"ospf" : {
"@" : {
"comment" : "/* New backbone area */"
},
"area" : [
{
"name" : "0.0.0.0",
"interface" : [
{
"@" : {
"comment" : "/* From jnpr1 \n to jnpr2 */"
},
"name" : "so-0/0/0.0",
"hello-interval" : 5,
"@hello-interval" : {
"comment" : "# set by admin"
}
}
]
}
]
}
}
}
}