SDN Networks Programming Languages
Download as PPTX, PDF2 likes3,160 views
The document discusses three programming languages for network management: Flog, Nettle, and Fattire, which aim to simplify the management of software-defined networks (SDNs) and enhance fault tolerance. Flog combines high-level policy operators and a declarative query language for packet forwarding, while Nettle utilizes functional reactive programming for controlling OpenFlow switches. Fattire focuses on fault tolerance using regular expressions to describe network policies, translating programs into configurations for OpenFlow switches.
SDN Networks Programming Languages
- 1. Network Programming Languages Author: Flavio Vit Course: UNICAMP –MO611 Teleprocessamento e Redes Professor: Nelson da Fonseca June 18, 2014
- 2. Agenda • Introduction • Flog • Nettle • FatTire • Comparisons
- 3. Introduction • Flog: Logic Programming for Software-Defined Networks • Nettle: Taking the Sting Out of Programming Network Routers • FatTire: Fault Tolerating Regular Expressions
- 4. Networks Management In the past … • Networks managed through a set of complex, low-level, and heterogeneous interfaces • Firewalls + network address translators + load balancers + routers + switches == Configured separately • Thousands of lines low-level code in different domain-specific languages • Complex routing mechanisms (error-prone tasks)
- 5. Software Defined Networks Recently … • SDN – Software Defined Networks • Logically centralized Controller: – Managing distributed switches – General purpose machines – Working on routing decisions – Instruct the switches to install the necessary packet-forwarding rules.
- 6. Flog - An SDN Logic Programming Language • SDN packet-forwarding rule Predicate + Action + Priority • Example: Predicate: match packets based on the IP header (MAC, IP, etc.) Action: Drop, forward or flood the packet to ports Priority: rules are executed according with priorities
- 7. Flog • Combines two programing languages: – FML: • set of high-level built-in policy operators (SDN abstractions) • allow/deny certain flows • provide quality of service • Programing model Not flexible – Frenetic: • declarative query language - SQL-like syntax • functional stream-processing language • language for describing packet forwarding
- 8. Flog • From FML: – Programming for controlling software-defined networks • From Frenetic: Controller programs split into : 1. Mechanism for querying network state 2. Mechanism for processing data extracted from queries 3. Component for generating packet-forwarding policies (automatically push to the switches)
- 9. Flog • Event driven => execution of logic programs 1. Generates a packet-forwarding policy compiled and deployed on switches 2. Generates states : drive the logic program when the next network event is processed
- 10. Flog • Network Events: – Switches online / offline – Ports on switches active / inactive – Statistics gathered by switches – Packets arrive at the controller and require handling
- 11. Flog • Flow rule syntax example: flow(srcip=IP,vlan=V), V > 0 --> myvlans(IP,V) • When vlan tag is greater than 0, generate a network event every time a packet with a new srcip - vlan tag pair is detected • When this event generated, the rest of the logic program will be executed. • The initial data for the logic program will include the tuple myvlans(IP,V)
- 12. Flog Police Generation: • generating a routing policy for network switches: h1(F1), h2(F2), ... |> action, level(i) left of the |> : kinds of packets that match the forwarding rule. Specifies the packet fields (and switch and ports) that match the rule. right of the |> : action where to forward or flood the packets or how to modify them. level specifies the priority of the rule.
- 13. Flog • Example: # Network Events flow(dstip=IP), inport=2 --> seen(IP) # Information Processing seen(IP) +-> allow(IP) allow(IP) +-> allow(IP) # Policy Generation inport(2) |> fwd(1), level(0) allow(IP) --> srcip(IP), inport(1) |> fwd(2), level(0).
- 14. Nettle - Taking the Sting Out of Programming Network Routers • Networks of OpenFlow switches controlled using a high-level, declarative and expressive language • Based on the principles of functional reactive programming (FRP) • Embedded in Haskell => general-purpose purely functional programming language. • Domain Specific Language
- 15. Nettle • Layered architecture Family of DSLs - each member capturing a different network abstraction Haskell host language OpenFlow switches Nettle / OpenFlow lib instantiation of the Functional Reactive Programming
- 16. Nettle • Nettle/FRP as a language for expressing electrical circuits • Haskell’s arrow syntax: y ← sigfun −≺ x
- 17. Nettle • Focus on the stream of control messages among OpenFlow switches • Nettle => powerful collection of – Signal functions – Event operators
- 18. Nettle OpenFlow switches maintains flow table with flow entries: match IPs, header fields • Forwarding actions to specific ports, flooding, dropping packets are updated • Expirations settings expires a flow entry after prescribed time
- 19. Nettle • Nettle Controller transforms: stream of messages from switches stream of commands for switches
- 20. Nettle • Example: install the flow rule, whenever a switch joins the network
- 21. FatTire: Fault Tolerating Regular Expressions • Programs for fault tolerant Networks • Based on regular expressions • Main features: Expressive: easy to describe forwarding and fault tolerant policies Efficient: based on fast failover from OpenFlow Correct: reasoning about the behavior of the system during failure recovery
- 22. FatTire • Central feature: Regular expressions for sets of legal paths through the network • FatTire programs are translated to OpenFlow switch configurations • Automatic response to link failures with no controller intervention
- 23. FatTire • Example :OpenFlow Group and Route Tables
- 24. FatTire • Group and Rule Tables for previous slide
- 26. FatTire • FatTire program for this example Security policy: All SSH traffic must traverse the IDS - regular expressions over switches to describe legal paths Fault-tolerance policy: “with” annotation Forwarding must be resilient to a single link failure. Routing policy: Traffic from the gateway (GW) must be forwarded to the access switch (A), along any path
- 27. Comparisons Prog Lang Main Characteristic Advantages Disadvantages Flog - Network Event driven - Focused on packets flow - Simple - Combines Frenetic and FML Too simple and limited to flow control FatTire Targets fast failover mechanisms provided by OpenFlow standard - High level - Regular expression powered - Turns failover scenarios easier to understand Only focused over solving link failures configuration Nettle - allow fine-grained control over switch behavior - event-based programming model - Strong typed - Extensible Good question!!! I buy it!
- 28. References 1. Naga Praveen Katta, Jennifer Rexford, and David Walker. Logic Programming for Software-Defined Networks 1. Mark Reitblatt, Marco Canini, Arjun Guha, and Nate Foster. Fattire: Declarative fault tolerance for software defined networks 1. Andreas Voellmy and Paul Hudak. Nettle: Taking the Sting Out of Programming Network Routers