{"id":9768,"date":"2016-02-10T12:50:45","date_gmt":"2016-02-10T10:50:45","guid":{"rendered":"https:\/\/blog.zhaw.ch\/icclab\/?p=9768"},"modified":"2016-12-12T11:24:04","modified_gmt":"2016-12-12T09:24:04","slug":"service-function-chaining-using-the-sdk4sdn","status":"publish","type":"post","link":"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/","title":{"rendered":"Service Function Chaining using the SDK4SDN"},"content":{"rendered":"<p>Last week in Athens we integrated the SDK4SDN aka Netfloc in the <a href=\"http:\/\/www.t-nova.eu\/\" target=\"_blank\">T-Nova<\/a> Pilot testbed in order to showcase service function chaining using two endpoints and two VNFs (Virtual Network Functions).<\/p>\n<p>NETwork FLOws for Clouds (Netfloc) is an open source SDK for datacenter network programming developed in the ICCLab SDN initiative. It is comprised of set of tools and libraries that interoperate with the OpenDaylight controller. Netfloc exposes REST API abstractions and Java interfaces for network programmers to enable optimal integration in cloud datacenters and fully SDN-enabled end-to-end management of OpenFlow enabled switches.<\/p>\n<p><!--more--><\/p>\n<p>The PoP consisted of three OpenStack nodes (Juno), one node reserved for the SDN controller (the SDK) and one physical switch, Figure 1.<\/p>\n<p><a href=\"https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/sdk_testbed_demokritos.png\" rel=\"attachment wp-att-9783\"><img loading=\"lazy\" decoding=\"async\" class=\" wp-image-9783 aligncenter\" src=\"https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/sdk_testbed_demokritos-300x165.png\" alt=\"sdk_testbed_demokritos\" width=\"436\" height=\"246\" \/><\/a><\/p>\n<p style=\"text-align: center\">Figure 1. Pilot testbed setup used for the SFC<\/p>\n<p>The SDK4SDN has been implemented in Java programming language and it is currently integrated as a holistic component that includes a <a href=\"https:\/\/www.opendaylight.org\/lithium\" target=\"_blank\">Lithium<\/a> release\u00a0of the OpenDaylight controller. It has been to date tested and supported using OpenStack Kilo (in the ZHAW SDN testbed) and OpenStack Juno (in the <a href=\"http:\/\/www.medianetlab.gr\/\">Demokritos<\/a> testbed).<\/p>\n<p>To use SDK4SDN, the network needs to be fully SDN enabled through the OVS switches. The network interfaces of the switch should be connected to all of the other nodes.<\/p>\n<p><strong>Firewall Configuration of Neutron Node<\/strong><\/p>\n<p>The default SFC implementation requires disabling iptables rules that would prevent non-standard forwarding to OpenStack instances and avoid\u00a0dropping the packets that are transmitted by Nova instances. Nova-compute was prevented from creating the iptables rules by configuring the <a href=\"https:\/\/gist.github.com\/djoreilly\/db9c2d32a473c6643551\">Noop driver<\/a>\u00a0in the\u00a0<em>\/etc\/neutron\/plugins\/ml2\/ml2_conf.ini <\/em>file on<em>\u00a0<\/em>the control and the\u00a0<em>\/etc\/nova\/nova.conf<\/em>\u00a0file in the compute nodes.<\/p>\n<p><strong>Deployment and Installation<\/strong><\/p>\n<p>The SDK4SDN can only detect OVS topology. A Physical switch that supports OVS is for example the Pica8 switch in OVS mode.\u00a0The OVS configuration on the compute nodes has to be setup such that the switches are connected in layer 2 domain. For each compute node, an OVS port was configured that bridges the physical interfaces. Note that if a compute host has a single physical interface, then the IPs on that interface need to be attached to the internal interface of the OVS bridge.<\/p>\n<p>The OpenDaylight controller needs to be reachable via ports TCP 6640 and TCP 6633 from every OVS and also reachable via HTTP from an Orchestrator on the Northbound in order to accept the SFC instructions via REST calls.<\/p>\n<p>The steps in order to setup the environment are the following:<\/p>\n<ol>\n<li>Login to all OpenStack nodes, the switch and ODL node as <em>root <\/em><\/li>\n<li>Download the SDK4SDN form the <a href=\"https:\/\/github.com\/icclab\/netfloc\" target=\"_blank\">GitHub page<\/a>\u00a0and compile the code using: <em>mvn clean install<\/em><\/li>\n<li>Configure the OVSs on each of the nodes to connect to the IP of the Open Daylight controller as well as set up the ODL as manager on port 6640:<\/li>\n<\/ol>\n<pre><code>ovs-vsctl set-manager tcp:Controller_IP:6640\r\novs-vsctl set-contorller tcp:Controller_IP:6633\r\n<\/code><\/pre>\n<p>With these basic steps the SDK is ready to be started as long as we have the environment prepared for this. To make sure all the state is clear before running the SDK, the following steps and checkups are required:<\/p>\n<ul>\n<li>OVS running in all of the nodes (run <em>ovs-vsctl show<\/em> to confirm and also check the configuration of the OVSs)<\/li>\n<li>SDK not running: .\/karaf\/target\/assembly\/bin\/status<\/li>\n<li>Cleanup OpenStack environment (delete all: VMs, router interfaces, routers, and networks)<\/li>\n<li>Make sure you delete the following directories in the SDN node:<\/li>\n<\/ul>\n<pre><code>rm -rf karaf\/target\/assembly\/data\r\nrm -rf karaf\/target\/assembly\/journal\r\nrm -rf karaf\/target\/assembly\/snapshots\r\n<\/code><\/pre>\n<p>After the above steps start the SDN controller (the SDK):\u00a0<em>.\/karaf\/target\/assembly\/bin\/start<\/em>.<br \/>\nTo monitor the logs on the SDN node run:\u00a0<em>tail -f .\/karaf\/target\/assembly\/data\/log\/karaf.log<\/em>.<br \/>\nIt displays the initialization process and the link discovery. The SDK startup is done when the last log message from ODL displays: <em>GraphListener<\/em>. Next, the basic networking environment has to be created: public network that connects via router to all the private networks that are designated for the\u00a0endpoint instances (sender &amp; receiver) and the VNFs.<\/p>\n<p>While creating the network elements in OpenStack, the SDK log displays how the neutron ports get detected and few seconds later, the same for the ovs ports. After that, the paths get detected and flows are pushed to the <em>br-int<\/em> of the controller. On the controller you can check the created ports and the flows: <em>ovs-vsctl show; ovs-ofctl dump-flows br-int<\/em>.<\/p>\n<p><strong>Service Function Chaining <\/strong><\/p>\n<p>Create two VMs: <em>sender<\/em> and <em>receiver<\/em> VM with for ex. CentOS image and\u00a0<em>tiny<\/em> flavor, connecting them to the internal private network. Create one VM destined for the dummy VNF (it can be created form snapshot dummy_vnf or simple Ubuntu image with OVS installed). Create another VM for the vTC VNF. After inserting the private keys, connect the VMs to the private network. In the control node, create four neutron ports <em>vnf1_in<\/em>,\u00a0<em>vnf1_out,\u00a0<em>vnf2_in<\/em>,\u00a0<em>vnf2_out<\/em> <\/em>and attach them to both the dummy VNF and the vTC VNF:<\/p>\n<pre><code>neutron port-create vnf_in\r\nneutron port-create vnf_out\r\nnova interface-attach --port-id [PORT_ID_vnf_in] vnf\r\nnova interface-attach --port-id [PORT_ID_vnf_out] vnf<\/code><\/pre>\n<p>The SDK log displays the addition of the new paths triggered by the creation of the VMs. At this point\u00a0the broadcast and path flows get created, Figure 2. To check this, go to the node where a VM is spawned, and <em>ovs-vsctl show<\/em> to see the flows installed. Besides the NORMAL and the LLDP flows, you can see other flows: broadcast flows to the Router, the DHCP and the other VMs; flows for connections between the VMs, etc.<\/p>\n<p><a href=\"https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/Netfloc_log.png\" rel=\"attachment wp-att-9777\"><img loading=\"lazy\" decoding=\"async\" class=\"size-medium wp-image-9777 aligncenter\" src=\"https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/Netfloc_log-300x282.png\" alt=\"Netfloc_log\" width=\"300\" height=\"282\" srcset=\"https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/Netfloc_log-300x282.png 300w, https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/Netfloc_log-768x723.png 768w, https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/Netfloc_log-1024x964.png 1024w, https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/Netfloc_log-319x300.png 319w, https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/Netfloc_log.png 1313w\" sizes=\"auto, (max-width: 300px) 100vw, 300px\" \/><\/a><\/p>\n<p style=\"text-align: center\">Figure 2. Netfloc log display: network path, graph, and bridge detection<\/p>\n<p>After the VNF has the two interfaces assigned from the other two private networks, associate a floating IP and access the VNFs.\u00a0Meanwhile login via the console to the <em>sender<\/em> VM and ping the <em>receiver<\/em> VM to confirm connectivity.\u00a0The dummy VNF represents a simplistic case of the T-Nova <a href=\"https:\/\/gerrit.opnfv.org\/gerrit\/yardstick\/tree\/vTC\">vTC VNF<\/a>\u00a0(Virtual traffic classifier).\u00a0For this demo we used the vTC as a second VNF.\u00a0The idea behind the basic functionality of this VNF is to steer traffic from one interface to another (ex. eth1 to eth2) and display the packets per second. More details on this VNF can be found <a href=\"https:\/\/www.youtube.com\/watch?v=MHghL4QyuSo\" target=\"_blank\">here<\/a>.<\/p>\n<p>Next step is to call the REST APIs via cURL in the command line of the ODL node in order to invoke the creation of the chain. For the API call, the neutron port IDs of the VMs need to be specified in order [<em>\u201csender, vnf1_in, vnf1_out,\u00a0<em>vnf2_in, vnf2_out,\u00a0<\/em>receiver\u201d<\/em>]\u00a0as a string of comma separated values. To retrieve the Neutron ports of the VMs, run on the controller: <em>neutron ports-list<\/em> and match the port-id with the IPs of both, the endpoints and the VNFs. The POST API call looks as shown below:<\/p>\n<p><a href=\"https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/SFC_create-1.png\" rel=\"attachment wp-att-9781\"><img loading=\"lazy\" decoding=\"async\" class=\"wp-image-9781 aligncenter\" src=\"https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/SFC_create-1-300x200.png\" alt=\"SFC_create\" width=\"430\" height=\"292\" \/><\/a><\/p>\n<p style=\"text-align: center\">Figure 3. SFC Create request<\/p>\n<p>After correct chain establishment, there is 200 OK response message form the SDK and on the sender console it is no longer detected the ping communication between the <em>sender<\/em> and the <em>receiver<\/em>. This shows that there is intermediate node(s) (the dummy_vnf and the vTC) blocking the ping, which confirms a traffic redirection from the initial path. In order to get the traffic through, the following flow has to be added in the dummy VNF:<\/p>\n<pre><code>ovs-ofctl add-flow [vnf_br] in_port=1,actions=output:2<\/code><\/pre>\n<p>Make sure of the correct mapping between the input and output ports and also that the two ports <em>eth1<\/em> and <em>eth2<\/em> are properly listed in the:\u00a0<em>ovs-ofctl dump-ports-desc [vnf_br]<\/em>.\u00a0After seting up the first VNF in the chain, the following command connects the interfaces in the vTC VNF the same way for the dummy VNF:<\/p>\n<pre><code>vtc\/PF_RING\/userland\/examples\/pfbridge -a eth1 -b eth2<\/code><\/pre>\n<p>Having all set, confirm that the ping goes through again. This\u00a0can be also checked by running:<em> tcpdump \u2013i eth1 \/eth2 <\/em>on the node where the VNFs are running and checking for ICMP messages, as the left terminal on the Figure 4 shows.<\/p>\n<p><a href=\"https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/SFC_pkt_in.png\" rel=\"attachment wp-att-9780\"><img loading=\"lazy\" decoding=\"async\" class=\"wp-image-9780 aligncenter\" src=\"https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/SFC_pkt_in-300x63.png\" alt=\"SFC_pkt_in\" width=\"478\" height=\"115\" \/><\/a><\/p>\n<p>Figure 4. ICMP messages in the dummy VNF (left) and SFC flows on the switch (right)<\/p>\n<p>Run on the switch (or the hosts where the VNF VMs are installed) terminal: <em>ovs-vsctl dump-flows [br_name]<\/em> to see that the <em>packets_in<\/em> counter increases as the pinging proceeds (for the flows with priority=20, i.e. the chain flows, as the right Figure 4 shows). Delete the flow in the VNF in order to see that the ping stops: <em>ovs-ofctl del-flows vnf<\/em>.<\/p>\n<p>To delete the chain, a POST call is made using the <em>service-chain-id<\/em> as input parameter in the JSON string, Figure 5:<\/p>\n<p><a href=\"https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/SFC_delete.png\" rel=\"attachment wp-att-9779\"><img loading=\"lazy\" decoding=\"async\" class=\"size-medium wp-image-9779 aligncenter\" src=\"https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/SFC_delete-300x164.png\" alt=\"SFC_delete\" width=\"300\" height=\"164\" srcset=\"https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/SFC_delete-300x164.png 300w, https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/SFC_delete-768x421.png 768w, https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/SFC_delete-1024x561.png 1024w, https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/SFC_delete-500x274.png 500w, https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/SFC_delete.png 1267w\" sizes=\"auto, (max-width: 300px) 100vw, 300px\" \/><\/a><\/p>\n<p style=\"text-align: center\">Figure 5. SFC delete request<\/p>\n<p style=\"text-align: left\">In conclusion, we can apply the same technique using any other VNF as long as the Neutron port IDs of the VNF VMs are passed in the REST call to the SDK. Finally here is the video of the chaining process.<\/p>\n<p><a href=\"https:\/\/youtu.be\/j5pI2QpJK8U\">https:\/\/youtu.be\/j5pI2QpJK8U<\/a><\/p>\n<div class=\"pt-sm\">Schlagw\u00f6rter: <a href=\"https:\/\/blog.zhaw.ch\/icclab\/tag\/netfloc\/\">netfloc<\/a>, <a href=\"https:\/\/blog.zhaw.ch\/icclab\/tag\/sdk\/\">sdk<\/a>, <a href=\"https:\/\/blog.zhaw.ch\/icclab\/tag\/sdn\/\">SDN<\/a>, <a href=\"https:\/\/blog.zhaw.ch\/icclab\/tag\/sfc\/\">SFC<\/a>, <a href=\"https:\/\/blog.zhaw.ch\/icclab\/tag\/software-defined-networking\/\">software-defined networking<\/a>, <a href=\"https:\/\/blog.zhaw.ch\/icclab\/tag\/t-nova\/\">T-NOVA<\/a>, <a href=\"https:\/\/blog.zhaw.ch\/icclab\/tag\/vnf\/\">vnf<\/a><br><\/div>","protected":false},"excerpt":{"rendered":"<p>Last week in Athens we integrated the SDK4SDN aka Netfloc in the T-Nova Pilot testbed in order to showcase service function chaining using two endpoints and two VNFs (Virtual Network Functions). NETwork FLOws for Clouds (Netfloc) is an open source SDK for datacenter network programming developed in the ICCLab SDN initiative. It is comprised of [&hellip;]<\/p>\n","protected":false},"author":89,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"ngg_post_thumbnail":0,"footnotes":""},"categories":[1],"tags":[784,436,293,755,437,673,657],"features":[],"class_list":["post-9768","post","type-post","status-publish","format-standard","hentry","category-allgemein","tag-netfloc","tag-sdk","tag-sdn","tag-sfc","tag-software-defined-networking","tag-t-nova","tag-vnf"],"yoast_head":"<!-- This site is optimized with the Yoast SEO Premium plugin v27.2 (Yoast SEO v27.2) - https:\/\/yoast.com\/product\/yoast-seo-premium-wordpress\/ -->\n<title>Service Function Chaining using the SDK4SDN - Service Engineering (ICCLab &amp; SPLab)<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Service Function Chaining using the SDK4SDN\" \/>\n<meta property=\"og:description\" content=\"Last week in Athens we integrated the SDK4SDN aka Netfloc in the T-Nova Pilot testbed in order to showcase service function chaining using two endpoints and two VNFs (Virtual Network Functions). NETwork FLOws for Clouds (Netfloc) is an open source SDK for datacenter network programming developed in the ICCLab SDN initiative. It is comprised of [&hellip;]\" \/>\n<meta property=\"og:url\" content=\"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/\" \/>\n<meta property=\"og:site_name\" content=\"Service Engineering (ICCLab &amp; SPLab)\" \/>\n<meta property=\"article:published_time\" content=\"2016-02-10T10:50:45+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2016-12-12T09:24:04+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/sdk_testbed_demokritos-300x165.png\" \/>\n<meta name=\"author\" content=\"irenatr\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"irenatr\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"7 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/\"},\"author\":{\"name\":\"irenatr\",\"@id\":\"https:\/\/blog.zhaw.ch\/icclab\/#\/schema\/person\/da21ae5e2a240a1445465cfb1d0f1f2c\"},\"headline\":\"Service Function Chaining using the SDK4SDN\",\"datePublished\":\"2016-02-10T10:50:45+00:00\",\"dateModified\":\"2016-12-12T09:24:04+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/\"},\"wordCount\":1424,\"commentCount\":0,\"image\":{\"@id\":\"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/sdk_testbed_demokritos-300x165.png\",\"keywords\":[\"netfloc\",\"sdk\",\"SDN\",\"SFC\",\"software-defined networking\",\"T-NOVA\",\"vnf\"],\"articleSection\":[\"*.*\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/\",\"url\":\"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/\",\"name\":\"Service Function Chaining using the SDK4SDN - Service Engineering (ICCLab &amp; SPLab)\",\"isPartOf\":{\"@id\":\"https:\/\/blog.zhaw.ch\/icclab\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/sdk_testbed_demokritos-300x165.png\",\"datePublished\":\"2016-02-10T10:50:45+00:00\",\"dateModified\":\"2016-12-12T09:24:04+00:00\",\"author\":{\"@id\":\"https:\/\/blog.zhaw.ch\/icclab\/#\/schema\/person\/da21ae5e2a240a1445465cfb1d0f1f2c\"},\"breadcrumb\":{\"@id\":\"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/#primaryimage\",\"url\":\"https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/sdk_testbed_demokritos.png\",\"contentUrl\":\"https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/sdk_testbed_demokritos.png\",\"width\":767,\"height\":422},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Startseite\",\"item\":\"https:\/\/blog.zhaw.ch\/icclab\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Service Function Chaining using the SDK4SDN\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/blog.zhaw.ch\/icclab\/#website\",\"url\":\"https:\/\/blog.zhaw.ch\/icclab\/\",\"name\":\"Service Engineering (ICCLab &amp; SPLab)\",\"description\":\"A Blog of the ZHAW Zurich University of Applied Sciences\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/blog.zhaw.ch\/icclab\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/blog.zhaw.ch\/icclab\/#\/schema\/person\/da21ae5e2a240a1445465cfb1d0f1f2c\",\"name\":\"irenatr\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/secure.gravatar.com\/avatar\/e4eade01f525f84b6d6542ababe6db35882b518534e07d5e95434edbe327bed0?s=96&d=mm&r=g\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/e4eade01f525f84b6d6542ababe6db35882b518534e07d5e95434edbe327bed0?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/e4eade01f525f84b6d6542ababe6db35882b518534e07d5e95434edbe327bed0?s=96&d=mm&r=g\",\"caption\":\"irenatr\"},\"url\":\"https:\/\/blog.zhaw.ch\/icclab\/author\/irenatr\/\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Service Function Chaining using the SDK4SDN - Service Engineering (ICCLab &amp; SPLab)","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/","og_locale":"en_US","og_type":"article","og_title":"Service Function Chaining using the SDK4SDN","og_description":"Last week in Athens we integrated the SDK4SDN aka Netfloc in the T-Nova Pilot testbed in order to showcase service function chaining using two endpoints and two VNFs (Virtual Network Functions). NETwork FLOws for Clouds (Netfloc) is an open source SDK for datacenter network programming developed in the ICCLab SDN initiative. It is comprised of [&hellip;]","og_url":"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/","og_site_name":"Service Engineering (ICCLab &amp; SPLab)","article_published_time":"2016-02-10T10:50:45+00:00","article_modified_time":"2016-12-12T09:24:04+00:00","og_image":[{"url":"https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/sdk_testbed_demokritos-300x165.png","type":"","width":"","height":""}],"author":"irenatr","twitter_card":"summary_large_image","twitter_misc":{"Written by":"irenatr","Est. reading time":"7 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/#article","isPartOf":{"@id":"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/"},"author":{"name":"irenatr","@id":"https:\/\/blog.zhaw.ch\/icclab\/#\/schema\/person\/da21ae5e2a240a1445465cfb1d0f1f2c"},"headline":"Service Function Chaining using the SDK4SDN","datePublished":"2016-02-10T10:50:45+00:00","dateModified":"2016-12-12T09:24:04+00:00","mainEntityOfPage":{"@id":"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/"},"wordCount":1424,"commentCount":0,"image":{"@id":"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/#primaryimage"},"thumbnailUrl":"https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/sdk_testbed_demokritos-300x165.png","keywords":["netfloc","sdk","SDN","SFC","software-defined networking","T-NOVA","vnf"],"articleSection":["*.*"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/","url":"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/","name":"Service Function Chaining using the SDK4SDN - Service Engineering (ICCLab &amp; SPLab)","isPartOf":{"@id":"https:\/\/blog.zhaw.ch\/icclab\/#website"},"primaryImageOfPage":{"@id":"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/#primaryimage"},"image":{"@id":"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/#primaryimage"},"thumbnailUrl":"https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/sdk_testbed_demokritos-300x165.png","datePublished":"2016-02-10T10:50:45+00:00","dateModified":"2016-12-12T09:24:04+00:00","author":{"@id":"https:\/\/blog.zhaw.ch\/icclab\/#\/schema\/person\/da21ae5e2a240a1445465cfb1d0f1f2c"},"breadcrumb":{"@id":"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/#primaryimage","url":"https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/sdk_testbed_demokritos.png","contentUrl":"https:\/\/blog.zhaw.ch\/icclab\/files\/2016\/02\/sdk_testbed_demokritos.png","width":767,"height":422},{"@type":"BreadcrumbList","@id":"https:\/\/blog.zhaw.ch\/icclab\/service-function-chaining-using-the-sdk4sdn\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Startseite","item":"https:\/\/blog.zhaw.ch\/icclab\/"},{"@type":"ListItem","position":2,"name":"Service Function Chaining using the SDK4SDN"}]},{"@type":"WebSite","@id":"https:\/\/blog.zhaw.ch\/icclab\/#website","url":"https:\/\/blog.zhaw.ch\/icclab\/","name":"Service Engineering (ICCLab &amp; SPLab)","description":"A Blog of the ZHAW Zurich University of Applied Sciences","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/blog.zhaw.ch\/icclab\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/blog.zhaw.ch\/icclab\/#\/schema\/person\/da21ae5e2a240a1445465cfb1d0f1f2c","name":"irenatr","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/e4eade01f525f84b6d6542ababe6db35882b518534e07d5e95434edbe327bed0?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/e4eade01f525f84b6d6542ababe6db35882b518534e07d5e95434edbe327bed0?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/e4eade01f525f84b6d6542ababe6db35882b518534e07d5e95434edbe327bed0?s=96&d=mm&r=g","caption":"irenatr"},"url":"https:\/\/blog.zhaw.ch\/icclab\/author\/irenatr\/"}]}},"_links":{"self":[{"href":"https:\/\/blog.zhaw.ch\/icclab\/wp-json\/wp\/v2\/posts\/9768","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blog.zhaw.ch\/icclab\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blog.zhaw.ch\/icclab\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blog.zhaw.ch\/icclab\/wp-json\/wp\/v2\/users\/89"}],"replies":[{"embeddable":true,"href":"https:\/\/blog.zhaw.ch\/icclab\/wp-json\/wp\/v2\/comments?post=9768"}],"version-history":[{"count":18,"href":"https:\/\/blog.zhaw.ch\/icclab\/wp-json\/wp\/v2\/posts\/9768\/revisions"}],"predecessor-version":[{"id":9793,"href":"https:\/\/blog.zhaw.ch\/icclab\/wp-json\/wp\/v2\/posts\/9768\/revisions\/9793"}],"wp:attachment":[{"href":"https:\/\/blog.zhaw.ch\/icclab\/wp-json\/wp\/v2\/media?parent=9768"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blog.zhaw.ch\/icclab\/wp-json\/wp\/v2\/categories?post=9768"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blog.zhaw.ch\/icclab\/wp-json\/wp\/v2\/tags?post=9768"},{"taxonomy":"features","embeddable":true,"href":"https:\/\/blog.zhaw.ch\/icclab\/wp-json\/wp\/v2\/features?post=9768"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}