[Contents] [Prev] [Next] [Index] [Report an Error]
Routing-Instances Configuration Statement Hierarchy

To configure routing instances, use the following statements at the [edit routing-instances] hierarchy level.
Shared JUNOS statements in the routing-instances hierarchy are shown in normal font and are documented in the JUNOS Routing Protocols Configuration Guide, the JUNOS Services Interfaces Configuration Guide, the JUNOS Multicast Protocols Configuration Guide, and the JUNOS Network Interfaces Configuration Guide.


routing-instances {


           
             routing-instance-name         
  {
description              text           ;


             
                                      
  forwarding-options{


accounting                  group-name                {


output {
aggregate-export-interval                    seconds       
         ;


cflowd  
                   hostname                 
  {


aggregation {
autonomous-system;
destination-prefix;
protocol-port;


source-destination-prefix
{
caida-compliant;
}


source-prefix;
}


autonomous-system-type (origin
| peer);
port    
                 port-number                
  ;
version  
                   number                   ;
}


flow-active-timeout                    seconds       
         ;
flow-inactive-timeout                    seconds       
         ;


interface                      interface-name        
           {
engine-id                      number                
  ;
engine-type                      number                
  ;
source-address                      address               
   ;
}


}


}




family {


inet {
filter (input                    input-filter-name       
          | output                    output-filter-name                 );
}




inet6 {
filter (input                    input-filter-name       
          | output                    output-filter-name                 );
}




mpls {
filter (input                    input-filter-name       
          | output                    output-filter-name                 );
}


}




helpers {


bootp {
client-response-ttl                    value         
       ;
description                    text                 ;


interface                      interface-name        
           {
client-response-ttl                      value       
           ;
description                      text                   ;
maximum-hop-count                      number      
            ;
minimum-wait-time                      seconds     
             ;
no-listen;


server  
                     address                
     {
routing-instance [                       value     
               ];
}


vpn;
}


maximum-hop-count                    number        
        ;
minimum-wait-time                    seconds       
         ;
relay-agent-option;


server  
                   address                    {
routing-instance [                     value       
           ];
}


vpn;
}




domain {
description                    text                 ;


interface                      interface-name        
           {
description                      text                   ;
no-listen;


server  
                     address                
     {
routing-instance [                       value     
               ];
}


}




server  
                   address                    {
routing-instance [                     value       
           ];
}


}




port    
               port-number                  {
description                    text                 ;


interface                      interface-name        
           {
description                      text                   ;
no-listen;


server  
                     address                
     {
routing-instance [                       value     
               ];
}


}




server  
                   address                    {
routing-instance [                     value       
           ];
}


}




tftp {
description                    text                 ;


interface                      interface-name        
           {
description                      text                   ;
no-listen;


server  
                     address                
     {
routing-instance [                       value     
               ];
}


}




server  
                   address                    {
routing-instance [                     value       
           ];
}


}




traceoptions {
file    
               filename                  <files                    number                 > <match                
   regular-expression                 >
<size                    maximum-file-size       
         >
<world-readable | no-world-readable>;


flag {
address;
all;
bootp;
config;
domain;
ifdb;
io;
main;
port;
rtsock;
tftp;
trace;
ui;
util;
}


level   
                match-level                 ;
}


}




packet-capture {
disable;
file    
             filename                <files                  number          
    > <size                  maximum-file-size               > 
<world-readable | no-world-readable>;
maximum-capture-size                  size            
  ;
}




sampling {
disable;


input {


family {


inet {
max-packets-per-second                        seconds   
                 ;
rate    
                   rate                     ;
run-length                        number              
      ;
}


}




output {


cflowd  
                     hostname               
      {
aggregation;
autonomous-system-type (origin
| peer);
(local-dump | no-local-dump);
port    
                   port-number              
      ;
source-address                        address             
       ;
version  
                     number                 
   ;
}


file    
                 filename                    <disable> <files                      number                   > <size                      maximum-file-size     
             > 
<stamp | no-stamp>
<world-readable | no-world-readable>;
flow-active-timeout                      seconds     
             ;
flow-inactive-timeout                      seconds     
             ;


interface                        interface-name      
               {
engine-id                        number              
      ;
engine-type                        number              
      ;
source-address                        address             
       ;
}


}




traceoptions {
file    
                 filename                    <files                      number                   > <size               
      maximum-file-size                   >
<world-readable | no-world-readable>;
}


}


}


instance-type (forwarding
| I2vpn | no-forwarding | virtual-router | vpls | vrf);
interface                interface-name             ;


multicast-snooping-options
{
flood-groups [                 value               ];


forwarding-cache {
threshold (suppress | reuse)
value                    value                 ;
timeout  
                 minutes                 ;
}




options {


syslog {
level   
                  level                    | upto                      level                                      ; 
               

mark seconds;
}


}


}


no-local-switching;
no-vrf-advertise;


protocols {


bgp {
                 
                   bgp-configuration       
         ;
}




esis {
                 
                   esis-configuration      
          ;
}




isis {
                 
                   isis-configuration      
          ;
}




l2vpn {
                 
                   l2vpn-configuration     
           ;
}




ldp {
                 
                   ldp-configuration       
         ;
}




msdp {
                 
                   msdp-configuration;     
                          

}




ospf {
domain-id                    domain-id               
 ;
domain-vpn-tag                    number                 ;
route-type-community (vendor
| iana);
                 
                   ospf-configuration      
          ;
}




ospf3 {
domain-id                    domain-id               
 ;
domain-vpn-tag                    number                 ;
route-type-community (vendor
| iana);
                 
                   ospf3-configuration     
           ;
}




pim {


mdt {
group-range                      multicast-prefix      
            ;


threshold {


group   
                      group-address         
              {


source  
                         source-address     
                    {
rate    
                       threshold-rate       
                 ;
}


}


}


tunnel-limit                      limit                 
 ;
}


                 
                   pim-configuration       
         ;
}




rip {
                 
                   rip-configuration       
         ;
}




router-discovery {
                 
                   router-discovery-configuration                 ;
}


}




provider-tunnel {


pim-asm {
group-address                    group-address           
     ;
}




rsvp-te {
label-switched-path-template
(default |                    lsp-template-name                 );
static-lsp                    p2mp-lps-name           
     ;
}




selective {
group   
                group-prefix                 ;
tunnel-limit                    number                 ;
}


}


route-distinguisher (               as-number         
   :               number              |                ip-address             :               number             );


routing-options {


aggregate {


defaults {
                   
                     aggregate-options                   ;
}




route   
                  destination-prefix        
           {
                   
                     aggregate-options                   ;
policy  
                   policy-name              
    ;
}


}




auto-export {
(disable | enable);


family {


inet {
disable;


flow {
(disable | enable);
rib-group                          rib-group         
             ;
}




multicast {
(disable | enable);
rib-group                          rib-group         
             ;
}




unicast {
(disable | enable);
rib-group                          rib-group         
             ;
}


}




inet6 {
disable;


multicast {
(disable | enable);
rib-group                          rib-group         
             ;
}




unicast {
(disable | enable);
rib-group                          rib-group         
             ;
}


}




iso {
disable;


unicast {
(disable | enable);
rib-group                          rib-group         
             ;
}


}


}




traceoptions {
file    
                 filename                    <files                     number                   > <no-stamp> <replace> 
<size                      maximum-file-size     
             > 
<world-readable | no-world-readable>;
flag    
                 flag                    <                     flag-modifier                   > <disable>; 
}


}




autonomous-system                    autonomous-system                  <loops                 
  number                 > {
independent-domain;
}




fate-sharing {


group   
                  group-name                
   {
cost    
                 value                   ;


from    
                   address                  
   {
to      
                 address                     ;
}


}


}




flow {


route   
                  name                    {


match {
                     
                       match-conditions                     ;
}




then {
                     
                       actions   
                 ;
}


}




validation {


traceoptions {
file    
                   filename                 
    <files                       number                     > <no-stamp> <replace> 
<size 
                      maximum-file-size     
               > 
<world-readable | no-world-readable>;
flag    
                   flag                      <                       flag-modifier                     > <disable>;
}


}


}




forwarding-table {
unicast-reverse-paths (active-paths
| feasible-paths);
}




generate {


defaults {
                   
                     generate-options                   ;
}




route   
                  destination-prefix        
           {
                   
                     generate-options                   ;
policy  
                   policy-name              
    ;
}


}




graceful-restart {
disable;
restart-duration                    duration                 ;
}


instance-export [                 policy-names               ];
instance-import [                 policy-names               ];


interface-routes {


family (inet | inet6) {
import [ 
                   import-policies          
        ];


export {
lan;
point-to-point;
}


}




rib-group {
inet    
                 group-name                 
 ;
inet6   
                  group-name                
  ;
}


}




martians {
                 
                   destination-prefix      
                                              match-type                  <allow>; 
}


maximum-paths                  path-limit                <log-only | threshold                  value                log-interval                  seconds               >;
maximum-prefixes                  prefix-limit                <log-only | threshold                  value                log-interval                  seconds               >;


multicast {


flow-map                      map-name              
     {


bandwidth                        value               
      {
adaptive;
}




forwarding-cache {


timeout  
                       minutes              
         {
never;
}


}


policy [ 
                   policy-name              
    ];
redundant-sources [                     source-address                   ];
}




forwarding-cache {
threshold (suppress | reuse)
value                      value                   ;
timeout  
                   minutes                   ;
}




interface                      interface-name        
           {
maximum-bandwidth                      limit       
           ;
}


rpf-check-policy [                   value         
       ];


scope   
                  scope-name                
   {
interface [                     interface-name        
                             ];
prefix  
                   destination-prefix       
           ;
}


scope-policy [                   policy-name             
                    ];
ssm-groups [                   addresses               
                  ];


ssm-map  
                   map-name                 
  {
policy [ 
                   policy-name              
    ];
source [ 
                   source-address           
       ];
}


}




multipath {


vpn-unequal-cost {
equal-external-internal;
}


}




options {
mark    
               seconds                 ;
syslog (level                    level                  | upto                    level                 );
}




resolution {


rib     
                routing-table-name          
         {
import [ 
                   policy-names             
     ];
resolution-ribs [                     routing-table-names   
               ];
}


}




rib     
              routing-table-name            
     {


aggregate {


defaults {
                     
                       aggregate-options                     ;
}




route   
                    destination-prefix      
               {
                     
                       aggregate-options                     ; 
policy  
                     policy-name            
        ; 
}


}




generate {


defaults {
                     
                       generate-options                     ;
}




route   
                    destination-prefix      
               {
                     
                       generate-options                     ;
policy  
                     policy-name            
        ;
}


}




martians {
                   
                     destination-prefix                                            
              match-type                    <allow>; 
}


maximum-paths                    path-limit              
   <log-only | threshold                  
 value                  log-interval                    seconds       
         >;
maximum-prefixes                    prefix-limit            
     <log-only | threshold                
   value                  log-interval
                 
                   seconds                 >;


multipath {


vpn-unequal-cost {
equal-external-internal;
}


}




static {


defaults {
                     
                       static-options                     ;
}


rib-group                      group-name            
      ;


route   
                    destination-prefix      
               {


                       
bfd-liveness-detection {                     



                       
 
detection-time {                       

                       
 
                            
                                                                           threshold       
                                             
                        milliseconds        
                                         ;                       

}


holddown-interval                          milliseconds;                                            

                       
local-address                                                 ip-address        
                                     ;  
                  

                       
minimum-interval                                                 milliseconds      
                                       ; 
                   

                       
minimum-receive-interval                                                 milliseconds                                              ;                     

                       
minimum-receive-ttl                                                 milliseconds      
                                       ; 
                   

                       
multiplier                         
                       number               
                              ;         
           

                       
neighbor                          
                      address               
                              ;         
           



                       
 
transmit-interval {                       

                       
 
                           minimum-interval                                                                              milliseconds   
                                              ;                       

                       
 
                            
                                                                           threshold       
                                             
                        milliseconds        
                                         ;                       

}


                       
version (0 | 1);                     

}




lsp-next-hop                         nexthop           
            {
metric  
                       metric               
       ;
preference                          preference        
              ;
}


                     
                       next-hop  
                                        [                                            nexthop                                          ];


qualified-next-hop (                         address 
                      |                      
   interface-name                       ) {
interface                          interface-name    
                  ;
metric  
                       metric               
       ;
preference                          preference        
              ;
}


                     
                       static-options                     ;
}


}


}


router-id                  address               ;


static {


defaults {
                   
                     static-options                   ;
}


rib-group                    group-name              
  ;


route   
                  destination-prefix        
           {


                     
bfd-liveness-detection {                   



                       
detection-time {                     

                       
                                 
                                             
                threshold                   
                                             
      milliseconds                                              ;                     

}


holddown-interval                        milliseconds;                                        

                     
local-address                                             ip-address          
                               ;        
          

                     
minimum-interval                                             milliseconds        
                                 ;      
            

                     
minimum-receive-interval                                             milliseconds                                          ;                   

                     
minimum-receive-ttl                                             milliseconds        
                                 ;      
            

                     
multiplier                        
                    number                  
                       ;                
  

                     
neighbor                          
                  address                   
                      ;                 
 



                       
transmit-interval {                     

                       
                         minimum-interval                                                                        milliseconds     
                                        ;                     

                       
                                 
                                             
                threshold                   
                                             
      milliseconds                                              ;                     

}


                     
version (0 | 1);                   

}




lsp-next-hop                        nexthop             
        {
metric  
                     metric                 
   ;
preference                        preference          
          ;
}


                   
                     next-hop    
                                  [     
                                  nexthop                                      ];


qualified-next-hop (                       address   
                  |                        interface-name                     ) {
interface                        interface-name      
              ;
metric  
                     metric                 
   ;
preference                        preference          
          ;
}


                   
                     static-options                   ;
}


}


}


vlan-id (all | none |                vlan-id           
 );


vlan-tags {
inner   
              vlan-id               ;
outer   
              vlan-id               ;
}


vrf-export [               policy-names             ];
vrf-import [               policy-names             ];
vrf-table-label;


vrf-target {
export  
               community-name               ;
import  
               community-name               ;
}


}


}


}
[Contents] [Prev] [Next] [Index] [Report an Error]