CCIE Pursuit Blog

April 29, 2008

Internetwork Expert Volume II: Lab 5 – Section 7

QoS – 8 Points

7.1 Frame Relay Traffic Shaping

We need to configure FRTS on r1.

AIR = 512Kbps
CIR = 384Kbps
MINCIR = 256Kbps
Be = Up to port speed
Tc = 100ms

We also know that we need to use adaptive shaping.

Bc = CIR * (Tc/1000)
Be = (AR – CIR) * (Tc/1000)

Adaptive Frame Relay Traffic Shaping for Interface Congestion

Frame-Relay Traffic Shaping

We can knock out the easy ones first:

map-class frame-relay FRTS
 frame-relay cir 384000
 frame-relay mincir 256000
 frame-relay adaptive-shaping becn

Now we just need to configure Bc and Be.

Bc = CIR * (Tc/100)
Bc = 384000 * (100/1000)
Bc = 384000 * .1
Bc = 38400

Be = (AR – CIR) * (Tc/1000)
Be = (512000 – 384000) * (100/1000)
Be = (128000) * (.1)
Be = 12800

So our final map-class is:

map-class frame-relay FRTS
 frame-relay cir 384000
 frame-relay bc 38400
 frame-relay be 12800
 frame-relay mincir 256000
 frame-relay adaptive-shaping becn

r1(config#int s0/0
r1(config-if)#frame traffic
r1(config-if)#frame interface-dlci 113
r1(config-fr-dlci)#class FRTS

r1(config-if)#do sh traffic

Interface   Se0/0
       Access Target    Byte   Sustain   Excess    Interval  Increment Adapt
VC     List   Rate      Limit  bits/int  bits/int  (ms)      (bytes)   Active
103           56000     875    7000      0         125       875       –
104           56000     875    7000      0         125       875       –
105           56000     875    7000      0         125       875       –
113           384000    6400   38400     12800     100       4800      BECN 
102           56000     875    7000      0         125       875       –

IE simply applies the map-class to the interface.  I don’t agree with their solution as all PVCs are affected and not just the PVC to r1.  Of course, only DLCI 113 is actually being used so…..ask your friendly proctor for clarification.  🙂

7.2 RTP Header Compression

Configure the Frame connection between r3 and r4 to support RTP header compression. 

ip rtp header-compression

r3’s s0/0 is a multipoint, physical Frame-Relay interface and we need to configure this only on the DLCI to r4.  I had to peek the answer on this one.

frame-relay map ip rtp header-compression

r3(config-if)# frame-relay map ip 162.1.0.4 304 rtp header-compression ?
  active            Always compress RTP headers
  connections       Maximum number of compressed RTP connections
  passive           Compress for destinations sending compressed RTP headers
  periodic-refresh  Send periodic refresh packets
  <cr>

Ummmm….did this blow away my broadcast capability

Before:
r3(config-if)#do sh run int s0/0:0 | i 162.1.0.4
 frame-relay map ip 162.1.0.4 304 broadcast

After:
r3(config-if)#do sh run int s0/0:0 | i 162.1.0.4
 frame-relay map ip 162.1.0.4 304 rtp header-compression passive connections 15

r3(config)#do sh frame map | sec 162.1.0.4
Serial0/0:0 (up): ip 162.1.0.4 dlci 304(0x130,0x4C00), static,
              CISCO, status defined, active
              RTP Header Compression (enabled), passive (enabled), connections: 15

Make sure that you leave your broadcast keyword in your map:

frame-relay map ip 162.1.0.4 304 broadcastrtp header-compression passive connections 15

Your connections need to match on both sides:

r4(config-if)#do sh run int s0/0 | i header
 frame-relay map ip 162.1.0.3 403 broadcast rtp header-compression connections 15

r3#sh ip rtp header-compression
RTP/UDP/IP header compression statistics:
 DLCI 304        Link/Destination info: ip 162.1.0.4
  Interface Serial0/0:0 DLCI 304 (compression off, Cisco, RTP, passive)
    Rcvd:    0 total, 0 compressed, 0 errors, 0 status msgs
             0 dropped, 0 buffer copies, 0 buffer failures
    Sent:    0 total, 0 compressed, 0 status msgs, 0 not predicted
             0 bytes saved, 0 bytes sent
    Connect: 15 rx slots, 15 tx slots,
             0 misses, 0 collisions, 0 negative cache hits, 15 free contexts

7.3 Bandwidth Limiting

“…Microsoft SQL traffic is limited to an average rate of 256Kbps on r2’s connection to the Frame Realy cloud.”
“Up to 2048 SQL packets in excess of 256Kbps should be queued up by r2 before packet loss occurs.”

Sounds like queueing to me.

“Do not use an access-list to accomplish this.”

That means we’ll be using a class-map with NBAR to match the traffic.

r2(config-cmap)#match protocol ?
—output truncated—
  sqlnet            SQL*NET for Oracle
  sqlserver         MS SQL Server

—output truncated—

We need to match on MICROSOFT SQL:

class-map match-all TASK_73
 match protocol sqlserver

r2(config-if)#policy-map TASK_73
r2(config-pmap)#class TASK_73
r2(config-pmap-c)#shape average 256000
r2(config-pmap-c)#shape ?
  adaptive        Enable Traffic Shaping adaptation to BECN
  average         configure token bucket: CIR (bps) [Bc (bits) [Be (bits)]],
                  send out Bc only per interval
  fecn-adapt      Enable Traffic Shaping reflection of FECN as BECN
  fr-voice-adapt  Enable rate adjustment depending on voice presence
  max-buffers     Set Maximum Buffer Limit
  peak            configure token bucket: CIR (bps) [Bc (bits) [Be (bits)]],
                  send out Bc+Be per interval

shape max-buffers

r2(config-pmap-c)#shape max-buffers 2048

r2(config-pmap-c)#int s0/0/0.1
r2(config-subif)#service-policy output TASK_73

r2(config-subif)#do sh policy-map int s0/0/0.1

 Serial0/0/0.1

  Service-policy output: TASK_73

    Class-map: TASK_73 (match-all)
      0 packets, 0 bytes
      5 minute offered rate 0 bps, drop rate 0 bps
      Match: protocol sqlserver
      Traffic Shaping
           Target/Average   Byte   Sustain   Excess    Interval  Increment
             Rate           Limit  bits/int  bits/int  (ms)      (bytes)
           256000/256000    1984   7936      7936      31        992

        Adapt  Queue     Packets   Bytes     Packets   Bytes     Shaping
        Active Depth                         Delayed   Delayed   Active
        –      0         0         0         0         0         no

    Class-map: class-default (match-any)
      23 packets, 2598 bytes
      5 minute offered rate 0 bps, drop rate 0 bps
      Match: any

 

Internetwork Expert Volume II: Lab 5 – Section 6

IPv6 – 12 Points

6.1 IPv6 Addressing

Very basic IPv6 addressing task.

6.2 IPv6 over Frame Relay

Easy IPv6 over Frame Relay task. 

The IE solution configured a link-local address on r1 and r3.  I did not.  This is a point-to-point connection so I saw no need for a link-local address.

Task 6.2

I did configure the link-local addresses on r2, r3, and r4 (along with frame maps) but it looks like those addresses and maps were not needed (actually, they used them later in the BGP IPv6 sections).

6.3 IPv6 BGP Advertisements

6.4 IPv6 BGP Summarization

6.5 IPV6 BGP

Since IPv6 BGP is not on the exam I simply read the solution guide for task 6.3 – 5 and configured my routers to match.

Question Of The Day: 29 April, 2008

Topic: OSPF

You have the following configuration on r1.

interface Loopback0
 ip address 1.1.1.1 255.0.0.0
!
router ospf 100
 router-id 1.1.1.1
 log-adjacency-changes
 network 1.1.1.1 0.0.0.0 area 0
 network 10.1.12.1 0.0.0.0 area 0

r2 is seeng the loopback address with a /32 mask:

r2#sh ip route ospf
     1.0.0.0/32is subnetted, 1 subnets
O       1.1.1.1 [110/2] via 10.1.12.1, 00:00:13, FastEthernet0/0

Using only a single command, make it so that r2 sees r1’s Loopback 0 with its configured network mask.

Click Here For The Answer


Yesterday’s Question

Question Of The Day: 28 April, 2008 

Topic: Frame Relay Traffic Shaping

Here is the current configuration for r1’s Frame Relay connection:

interface Serial1/0
 no ip address
 encapsulation frame-relay
!
interface Serial1/0.12 point-to-point
 ip address 10.1.12.1 255.255.255.0
 frame-relay interface-dlci 102

Configure r1 to match this output:

r1#show traffic-shape

Interface   Se1/0.12
       Access Target    Byte   Sustain   Excess    Interval  Increment Adapt
VC     List   Rate      Limit  bits/int  bits/int  (ms)      (bytes)   Active
102           512000    9600   51200     25600     100       6400      BECN

Answer:

map-class frame-relay FRTS
 frame-relay cir 512000
 frame-relay bc 51200
 frame-relay be 25600
 frame-relay adaptive-shaping becn
!
interface Serial1/0
 no ip address
 encapsulation frame-relay
 frame-relay traffic-shaping

!
interface Serial1/0.12 point-to-point *
 ip address 10.1.12.1 255.255.255.0
 frame-relay interface-dlci 102
  class FRTS

* There are actually three ways to apply this map-class to achieve the output in the question:

1)  Apply it to DLCI 102 only (method shown above).  Configure frame-relay traffic-shaping on the physical interface.  The subinterface will inherit that setting.  Next, configure the FRTS class under the frame-relay interface-dlci command.

interface Serial1/0
 frame-relay traffic-shaping
interface Serial1/0.12 point-to-point
 frame-relay interface-dlci 102
  class FRTS

2)  Configure frame-relay traffic-shaping on the physical interface.  The subinterface will inherit that setting.  Next, configure the FRTS class on the subinterface with the frame-relay class command.  This will apply the FRTS map-class to all DLCIs assocatiated with the s1/0.12 subinterface.  Since we’re using a point-to-point subinterface (only one DLCI allowed) we achieve the same results as method 1.  Keep in mind that if this is a multipoint subinterface this method would apply the map-class to all DLCIs associated with that subinterface.

interface Serial1/0
 frame-relay traffic-shaping
interface Serial1/0.12 point-to-point
 frame-relay class FRTS

3)  Configure frame-relay traffic-shaping on the physical interface.  The subinterface will inherit that setting.  Next, configure the FRTS class on the physical interface with the frame-relay class command.  All subinterfaces will inherit this map-class.  In our example we only have a single subinterface configured so this will achieve the same result as methods 1 and 2. 

interface Serial1/0
 frame-relay traffic-shaping
 frame-relay class FRTS

The biggest ‘gotcha’ with FRTS on subinterfaces is that you need to turn frame-relay traffic-shaping on for the physical interface.  If we add another subinterface to serial1/0 then we’ll end up with that subinterface inheriting a default frame-relay map-class (methods 1 and 2) or the FRTS map-class (method 3).

Methods 1 and 2:
r1(config-subif)#do sh traffic

Interface   Se1/0.12
       Access Target    Byte   Sustain   Excess    Interval  Increment Adapt
VC     List   Rate      Limit  bits/int  bits/int  (ms)      (bytes)   Active
102           512000    9600   51200     25600     100       6400      BECN

Interface   Se1/0.13
       Access Target    Byte   Sustain   Excess    Interval  Increment Adapt
VC     List   Rate      Limit  bits/int  bits/int  (ms)      (bytes)   Active
103           56000     875    7000      0         125       875       –  

Method 3:
r1(config-if)#do sh traffic

Interface   Se1/0.12
       Access Target    Byte   Sustain   Excess    Interval  Increment Adapt
VC     List   Rate      Limit  bits/int  bits/int  (ms)      (bytes)   Active
102           512000    9600   51200     25600     100       6400      BECN

Interface   Se1/0.13
       Access Target    Byte   Sustain   Excess    Interval  Increment Adapt
VC     List   Rate      Limit  bits/int  bits/int  (ms)      (bytes)   Active
103           512000    9600   51200     25600     100       6400      BECN

So how did we reverse-engineer the values for our map-class?  Let’s look at the original output:

r1#show traffic-shape

Interface   Se1/0.12
       Access Target    Byte   Sustain   Excess    Interval  Increment Adapt
VC     List   Rate      Limit  bits/int  bits/int  (ms)      (bytes)   Active
102           512000    9600   51200     25600     100       6400      BECN

VC= Virtual Circuit (DLCI) = 102
Access-List = access-group assigned to the interface = none
Target Rate= CIR = 512Mbps
Byte Limit= Bc + Be in bytes = 9600 (multiply by 8[bit] to get 76800 which jives with our Bc (51200) + Be (25600))
Sustain bits/int= Bc = 51200
Excess bits/int = Be = 25600
Interval (ms) = Tc in milliseconds = 100 ms
Increment (bytes)= No idea  🙂  It looks like it may be the Bc in bytes.
Adapt Active= Adaptive Shaping mechanism (if any) =  BECN (reduce to MINCIR value if a BECN is detected)

From this information we should be able to build our Frame Relay map-class:

map-class frame-relay FRTS
 frame-relay cir 512000 <- Target Rate
 frame-relay bc 51200 <- Sustain bits/int
 frame-relay be 25600 <- Excess bits/int 
 frame-relay adaptive-shaping becn <- Adapt Active

One thing to note is that you cannot determine the MINCIR value from the output provided.  Since we’re using adaptive shaping, there must be a MINCIR value established.  This is the tranmit rate that the interface will use if it detects a BECN.  By default this value is set to half of the CIR.  In our case the CIR is 512000 so our MINCIR is 256000:

r1(config-map-class)#do sh frame pvc 102 | b Shaping
  Shaping adapts to BECN
  pvc create time 00:28:39, last time pvc status changed 00:27:25
  cir 512000    bc 51200     be 25600     byte limit 9600   interval 100
  mincir 256000    byte increment 6400  Adaptive Shaping BECN
  pkts 370       bytes 30031     pkts delayed 0         bytes delayed 0       
  shaping inactive   
  traffic shaping drops 0
  Queueing strategy: fifo
  Output queue 0/40, 0 drop, 0 dequeued

I didn’t give that information in this question because the output explicitly shows you the Be and Bc values.  🙂  Technically I did not give you sufficient information to complete this task as the MINCIR value could have been set to a non-default value (384000) and you would not have known about it from the output provided.

The second point it that the Interval is derived from the formula (using a little bit of basic algebra):

Bc = CIR * (Tc/1000)
Bc/CIR = Tc/1000
(Bc/CIR)*1000 = Tc
Tc = (Bc/CIR)*1000
Tc = (51200/512000) * 1000
Tc = .1 * 1000
Tc = 100

My point is that you do not need to explicitly set the Tc with the ‘frame-relay tc’ command.  In fact, if you do try to set it after setting Bc and CIR, it will not change your Tc:

Let’s try to change the Tc:
r1(config)#map-class frame-relay FRTS
r1(config-map-class)#frame-relay tc 50r1(config-map-class)#do sh traffic

 

Interface   Se1/0.12
       Access Target    Byte   Sustain   Excess    Interval  Increment Adapt
VC     List   Rate      Limit  bits/int  bits/int  (ms)      (bytes)   Active
102           512000    9600   51200     25600     100       6400      BECN

As you can see, the Interval does not change.  If we want to set it to 50 ms, then we need to alter the Bc value.  In this case we would just cut it in half:

r1(config)#map-class frame-relay FRTS
r1(config-map-class)#frame-relay bc 25600 
r1(config-map-class)#do sh traffic

Interface   Se1/0.12
       Access Target    Byte   Sustain   Excess    Interval  Increment Adapt
VC     List   Rate      Limit  bits/int  bits/int  (ms)      (bytes)   Active
102           512000    6400   25600     25600     50        3200      BECN

 

Create a free website or blog at WordPress.com.