Cementing High Availability in OpenFlow with RuleBricks Dan Williams - - PowerPoint PPT Presentation

Cementing High Availability in OpenFlow with RuleBricks

Dan Williams & Hani Jamjoom

IBM T. J. Watson Research Center

Planning For Failure

Shift towards highly elastic applications Failure is elasticty's evil twin e.g., "Chaos Monkeys" by Netflix

2

Focus on One Question

How can high availability policies be added to OpenFlow’s forwarding rules?

Controller

Assumed Environment

Replicas Flow reassignment if VM2 fails Flows Active Backup plan VM1 VM2 VMN OpenFlow Switch Rule Set

4

Goals

Embed failure plans in existing environments Limit flow reassignments Limit rule explosion Keep it simple

5

Exploit Two Features

Hierarchical structure of OpenFlow’s wild card rules Precedence rule execution

6

Brick Representation

* 1* 0* 01* 00*

Binary Tree Bricks

IP address space

* 1* 0* 01* 00*

=

Brick width signifies address coverage Number of bricks depend on width of bricks

7

Flow Assignment

* 1* 0* 110* 10*

Use color to represent replica assignment

Flows a b c d

Flows matching 0* will be assigned to GREY replica

8

Active vs. Backup Rules

* 1* 0* 110* 10*

Flows will match top bricks

Flows a b c d e 01* 00*

Active rule set

9

Remember Tetris?

10

3 operations in RuleBricks

11

VM1 VM3 VM2 3 replicas, note their color

#1. Drop

* 100* 111* 10* 01* 00* 1* 0* 101* 000* Flows a b c d

12

Flows matching 000* will be assigned to WHITE replica

Add VM3, WHITE replica

Reassignment on Failure

* 00* 100* 111* 10* 101* 000* Flows a b c d e

13

VM2 dies, GREY bricks vanish

#2. Insert

* 100* 111* 10* 01* 00* 1* 0* 101* 000* 1* Flows a b c d e

14

Set WHITE to take over GREY's portion of 1*

#3. Reduce Transformations

100* 101* 10* 101* 101* 101* 101* 101* 101* 101*

defragment fragment deduplicate duplicate

15

Use a greedy algorithm that frags/defrags, then dedups starting with least exposed brick

Example

10* 1* 101* 1* 101* 11* 101*

1.Fragment:

11* 100* 1*

3.Defragment:

1* 100* 101* 100* 101* 100* 11*

2.Deduplicate:

11* 100* 101* 100* 101* 100*

16

Start:

What Can We Do With RuleBricks?

Encode Chord's assignment policy Hash-based assignment of nodes on a ring, representing the IP address space When a node is removed, successor node takes over

17

Encode Node Replica

00* 01* 10* 11* covers the entire IP address space Chord ring: RuleBricks: *

18

Adding a Replica

* 00* * 00* 01* 10* 11* backup rule active rule

19

Drop active rule bricks Insert backup rule bricks

Adding a Third Replica

00* 01* 101* 11* 100* * 100* * * 00* 00* 01*

20

active rules

Adding a Virtual Node

00* 01* 101* 11* 100* * 100* * * 00* 00* 01* 01* 00* *

21

Reducing Rules

00* 01* 101* 11* 100* * 100* * * 0* 00* 0*

22

Implementation

01* 00* 01* 00* Fixed-sized RuleBricks Variable-sized RuleBricks

Implemented RuleBricks in Python Looked at rule explosion for active rule set Looked at implication of having fixed vs. variable size bricks

23

Brick-based Rule Reduction

24

Use 16 virtual nodes per replica

Conclusion

Failure is elastcity’s evil twin RuleBricks simplifies planning for failure RuleBricks can embed different flow assignment policies

25