Monthly Archives: November 2016

Software Defined Networking Fundamentals Part 3: Transformation of Network Architecture


Explore Software Defined Networking Fundamentals today by downloading the free sample. Download Now

Join us in this three-part weekly blog series to get a sneak peek at The Linux Foundation’s Software Defined Networking Fundamentals (LFS265) self-paced, online course. 

Part 2 of this series discussed the architecture of a traditional data switch and the inherent limitations created when striving for the highest performance of wire speed switching.  This inflexibility and resultant vendor lock-in spawned Software Defined Networking (SDN)

According to Wikipedia,

“Software Defined Networking (SDN) is an approach to computer networking that allows network administrators to manage network services through abstraction of higher-level functionality. This is done by decoupling the system that makes decisions about where traffic is sent (the control plane) from the underlying systems that forward traffic to the selected destination (the data plane).”

As we saw in the previous article, the TCAM (Ternary Content Addressable Memory) in a traditional networking switch is the cornerstone of the Data Plane’s operation.

The foundations of SDN lie in the following question: What if we could access or program these remotely? We will discuss the consequences and effects next.

Changes to Networking Components

Software Defined Networking introduces new components to traditional networking infrastructure, as well as adapts the functionality of the existing components to the software defined architecture. The most important changes are:

• The physical or virtual switch (generalized as network device) does not have to implement all the protocols or features. Instead, it provides access to the data plane through a standardized API (e.g. OpenFlow). The software defined switch needs less internal logic thereby reducing complexities and costs.

• The concept of the SDN controller is new. It represents the control plane logic to the connected switches, calculates the forwarding state and populates the tables.  It will be discussed below.

• The applications that reside on top of the Services API provided by the controller are also new. It abstracts the differences in the switch hardware from the network applications (e.g. firewall, QoS, NaaS). Thus application programmers can program “the network” and they do not need to know the details and unique management interfaces of each and every switch in the network.  

The SDN Switch

The fundamental difference between a traditional switch and an SDN switch is the separation of the switch (data plane) and the controller (Control Plane). Once separated the control function doesn’t need to be co-located with the switching function.  Additionally, a single remote controller can manage/control multiple switches throughout the network.  Once the controller is managing switches  across the network these controller can glean more information about the state of the entire network and not just the state of switches or nodes of the network.  This additional information can be used in a number of ways such as dynamically modifying flows.  For example, if part of the network is highly congested the controller can re-program the forwarding tables to re-route sensitive traffic around the congested links and switches.

As illustrated in Figure 1, there is a split between the switch and the controller:

• The switch hardware will have a minimal abstraction layer, with some control and management functionality. This is needed for cold-start operation and configuration.

• The decisions are now made in the control plane, which is part of the controller. The controller offers a central management plane as well.

The SDN Controller and APIs

A key part of all of this is the Application Programming Interface (API).  APIs enable people and different layers of the network to communication with underlying components using a common and simplified approach.  Applications do not need to know the details of the underlying hardware,  they only need to know how to talk to a switch  using this common language, the API.   You do not need to know the vendor specific details as long as the vendor has implemented the API.  Thus, high layer functions can “program the network” and not individual hardware devices.   This network-wide programmability is a fundamental of SDN.  

SDN introduces a new component, the SDN Controller (Figure 2). The SDN Controller is connected to the switches and represents the control plane logic.  It’s responsible for calculating the forwarding rules and populates the switch’s tables.

When the controller is separated from the individual switch, a single controller is able to manage multiple SDN-capable devices.

This capability has some important consequences:

• A controller can aggregate more data regarding the state of the network.

• More knowledge about the state of the network leads to improved decisions.

• The flows can be dynamically adapted by the controller.

Network Transformation

SDN will transform the network away from specialized hardware with protocols and applications implemented for each Switch/Router hardware/software combination (Figure 3).  Instead, the functionality is implemented at a higher level, using the controllers’ APIs independent of the underlying hardware. Instead of programming individual devices, we can now program the network.  This is referred to as the separation of the Data Plane from the Control Plane.

The Internet Research Task Force (IRTF) RFC 7426 standard was released in January 2015 and it introduced a number of SDN fundamental concepts in the form of “abstraction layers”.  The first is that of the Network Services Abstraction Layer (NSAL).  This layer “sits” between the higher level applications and network services and the SDN Controllers.  It is the API for these controllers.  It also introduced other abstraction layers including the Control Abstraction Layer (CAL), the Management Abstraction Layer (MAL) and the Device and resource Abstraction Layer (DAL).  Each of these layers or APIs provide the higher layers with a common way to communicate their requirements to the layer or layers below them.

The terms “Northbound” and “Southbound” emanated from the way networks were illustrated.  The hardware was typically shown on the bottom of the whiteboard or Powerpoint slide and the applications, services and management systems were shown at the top.  In the middle is the network control logic.  Thus, above, northbound, from the controller are the services and applications and below, southbound, are the actual network elements.  Traditionally these interfaces were tightly coupled to the proprietary hardware-centric network elements resulting is the inflexibility previously discussed.  The APIs between the control and applications (northbound) and between the control and hardware (southbound) create a common “language” to communicate and thereby eliminates the need for programmers to learn vendor-specific management interfaces.  Today, any function or interface shown above a specific function is northbound and those below are southbound.  Most functions have both northbound and southbound interfaces and data traffic flows East and West.

The northbound SDN layer architecture (Figure 4) includes:                                           

  • The Network Services Abstraction Layer (NSAL), which represents the application API of the controller.            

  • Network Services are provided by the controller (the control and management planes) as Service Interfaces.                                        

The southbound SDN architecture (Figure 5) includes:

• The Control Abstraction Layer (CAL).

• The Management Abstraction Layer (MAL).

• The Device and resource Abstraction Layer (DAL).

This three-part series provides the history of how we got to where we are today and illustrates the fundamental difference with SDN: the separation of the control plane from the data plane. Once separated, network operators have new degrees of freedom in the design and management of large scale IP networks.  

The incorporation of application programming interfaces (API) into SDN is shown to greatly simplify the operation of these networks.  Network engineers and other professionals can both glean network-wide state and make network-wide programming changes without the need to understand the minute details of the features and functionalities above them (Northbound) or below them (Southbound).  Lastly, IETF RFC 7426 (Figure 6) was introduced showing the creation of a number of “abstraction layers” which standardize the locations of the APIs.  Each of these abstraction layers hides the complexity of logic on either side further simplifying the deployment and operation of large scale IP network.

After this course, you should understand the historical drivers that spawned SDN.  It then introduced the concept of “planes” and  illustrated the primary technical differences traditional hardware-centric switches with new software-centric switches, namely the separation of the control plane from the data plane.  Once separated, network operators will benefit from flexibility and visibility.  The control plane in SDN now has increased visibility to the entire network and not just each individual network devices.  Then RFC 7426 was discussed highlighting a number of abstraction layers created to simplify the underlying complexities and to accelerate innovation in software defined networks.

The “Software Defined Networking Fundamentals” training course from The Linux Foundation is designed to provide system and network administrators and engineers with the skills necessary to maintain an SDN deployment in a virtual networking environment. Download the sample chapter today!

Read the previous articles in the series:

Software Defined Networking Fundamentals Part 1: Intro to Networking Planes

Software Defined Networking Fundamentals Part 2: Switches and Network Architecture

CeBIT 2017: The Open Source Forum


CeBIT is the largest international computer expo, concentrating on the state of the art in information technology. CeBIT 2017 takes place March 20-24 in Hanover, Germany.

The Open Source Forum has been one of CeBIT’s most popular lecture platforms for years, according to visitor surveys. In about 60 presentations, the visitor learns everything worth knowing about open source, Linux, and free software. The 2017 theme day is planned around “Cloud/OpenStack.”

The Call for Papers seeks practitioners who report on their experiences in the development and use of free software. In addition to cloud, virtualization, and OpenStack topics, the focus is on the Internet of Things (IoT), embedded systems, system administration, and automation. Your presentation, including a question and answer session, should be in German or English and last between 20 and 40 minutes.

Interested parties should contact the organizers using the online form, or you may email callforpapers@linux-magazin.de with a brief description of the talk and a cell phone number. An international jury of open source experts will determine the allocation of lecture slots. A few slots are reserved for sponsors of the open source forum (contact: judith.gratias-klamt@computec.de).

In the Open Source Park adjacent to the forum, small and medium-sized companies present Linux and open source solutions to business concerns (contact: h.engels@pluspol.de).

The Open Source Forum takes place at CeBIT on March 20-24. Computec Media GmbH accepts proposals for lectures through January 15, 2017. Visit us in Hall 3 at booth D35.

Sponsors of CeBIT Open Source Forum 2017 are c.a.p.e. IT, Tuxedo Computers, and Versatio Software.



Source link

Ubuntu 16.10 (Yakkety Yak) Screenshots Tour


Codenamed “Yakkety Yak”, Ubuntu 16.10 continues Ubuntu’s proud tradition of integrating the latest and greatest open source technologies into a high-quality, easy-to-use Linux distribution. The team has been hard at work through this cycle, introducing new features and fixing bugs.

This screenshots tour shows you installation and applications

Ubuntu 16.10 (Yakkety Yak) Screenshots Tour

Sponsored Link



Related posts


Build Your Own Netflix and Pandora With Raspberry Pi 3


Do you have a huge collection of movies, TV shows, and music that you purchased over the years but it’s collecting digital dust on your hard drives? How about creating your very own Netflix- and Pandora-like setup using the free Plex Media Server software? No, you don’t have to buy an expensive, bulky PC. All you need is a Raspberry Pi 3, a hard drive, an SD card and a mobile charger. It should all cost less than $100.

What you need:

  • PC or laptop

  • Raspberry Pi 3

  • Micro SD card

  • A powered hard drive

  • 5v 2A power supply for Pi

  • Monitor, HDMI cable, keyboard and mouse (only for initial setup)

  • I also recommend a heat sink for Pi chips as multimedia consumption does make them hot

  • Ethernet cable (optional)

I will be using it in a headless manner, but we do need a monitor with an HDMI cable for initial setup.  On your PC/laptop, download the ‘NOOBS’ distribution installer from the official site. It’s a zip file, which you’ll extract using the unzip command.

Insert the Micro SD card and format it as FAT32 using Gnome Disk Utility.

gztF3kGsoByxxfjYXA_D-hfRAiwxGF1CqjNnb155

Then, change directory to the Micro SD card:

cd /path_of_USB

And unzip the NOOBS file into the Micro SD card:

unzip PATH_OF_NOOBS

In my case it was:

unzip /home/swapnil/Downloads/NOOBS_v1_9_2.zip

Just ensure that all the content of the NOOBS folder is in the root directory of the Micro SD card.

Now plug the monitor, keyboard and mouse into the Pi, insert the Micro SD card and connect the power supply. The system will boot up to NOOBS where you can choose the operating system you want to install. Choose Raspbian. Once the installation is finished, it will reboot into your brand new Raspbian OS. It will also automatically resize the file system to use all available space on the SD card.

If you can use an Ethernet cable, I would recommend that because it will give you faster speed compared to the WiFi on board. If not, then use the WiFi utility in Raspbian to connect to the wireless network. Once you are online, open the terminal and run the following command to find the IP address of your Pi:

if config

Once you have the IP address, open the terminal on your PC/laptop and ssh into your Pi:

ssh pi@IP_ADDRESS_OF_PI

The default password for the Pi is raspberry. If you want to change the password, run the following command and enter the new password after the prompt:

passwd pi

Now let’s update the system before we install Plex. This is a best practice for all fresh distro and software installations

sudo apt-get update

sudo apt-get dist-upgrade

Once updated, connect the external hard drive to your Pi using one of the USB ports. It’s best to use a hard drive that has been formatted in the ext4 file system for better compatibility with Linux. Mount it and create an entry in the ‘fstab’ so that it auto mounts between reboots.

Now it’s time to install Plex Media Server. We are using packages created by a third-party developer so let’s add their GPG key:

wget -O - https://dev2day.de/pms/dev2day-pms.gpg.key  | sudo apt-key add - 

Now add repos to the source list file:

echo "deb https://dev2day.de/pms/ jessie main" | sudo tee /etc/apt/sources.list.d/pms.list

Now update the system:

sudo apt-get update

And then install Plex Media Server:

sudo apt-get install -t jessie plexmediaserver -y

Now run it:

service plexmediaserver star

That’s it. You have Plex Media Server running on your Raspberry Pi 3.

Set up your media server

Plex Makes it extremely easy to set up your Plex Media Center. Now you need to point your Plex Media Center towards the media files: movies, music, and TV shows. You can do it from any PC in your local network. Just type this address into a web browser, filling in your own Pi’s IP address:

IP_ADDRESS_OF_PI:32400/web/index.html#

In my case it was:

10.0.0.26:32400/web/index.html#

This will open the Plex Media Server interface. The greatest feature of Plex is metadata that it pulls from the internet and attaches to your media files. But it’s extremely important to categorize your media otherwise Plex won’t detect it. So create these folders on your hard drive and store appropriate media inside the folders: movies, tv_shows, music, home_videos, photos.

Now copy movies to the movies folder, TV shows to the tv_shows folder, any videos that you take from your phone or camera to home_video folder, and so on. If you copy TV shows or home videos to movies or vice versa, those files won’t show up on Plex and you won’t be able to play them.

Once you have taken care of your media files, open the movie tab on the Plex Media Center interface and browse to add the movies folder from your hard drive. Repeat the step for each media type. Once done, give Plex some time to scan and process those files.

eEAS8rVfeHCjfwrG6m4StFGLCsBYG9MYfUp2s4k3

Another interesting thing that you can do with your Plex is add online video channels such as CNN, PBS, and History.… Just go to the ‘Channels’ option and install channels that you like. Now all of these channels, in addition to your movies, tv shows, music and photos are accessible through your Plex server running on the Pi.

w5N1FC1GJEqk2PlUcc2VyXBX9VakE3SZ4Yal7wjR

Access your Plex Media Server

There are many ways to access your Plex Media Center:

1. If you are on the local network open this URL in the web browser:

IP_ADDRESS_OF_PI:32400/web/index.html#

In my case it was:

10.0.0.26:32400/web/index.html#

It will open the Plex Media Player interface, just log into your media server and start playing content. You can also manage your Plex Media Server from this interface.

2. You can access your Plex Media Server from mobile devices using the official Plex app that’s available for both Android and iOS.

3. Or you can set up a Plex Media Player device (such as RasPlex) and turn any HDMI-enabled TV into your very own entertainment system. (See the next tutorial on how to do this!)

If you want to be able to access Plex outside of your home network then you can purchase PlexPass which allows you to stream your content across devices over the Internet. Because Plex also remembers playback history and where you are in any content, you can also add family members, just like Netflix, so that you can maintain your own viewing history.

All of this for just under $100, and you got to build it yourself. Isn’t it fun?

Read the previous articles in the series:

5 Fun Raspberry Pi Projects: Getting Started

How to Build a Minecraft Server with Raspberry Pi 3

For 5 more fun projects for the Raspberry Pi 3, including a holiday light display and Minecraft Server, download the free E-book today!

How to Build a Minecraft Server with Raspberry Pi 3


The beauty of the Raspberry Pi 3 is that you can tinker and do fun stuff to your heart’s content. This tiny $35 computer lets you do anything.

The Pi I have runs Raspbian for other uses. I keep several micro SD cards, each with different applications and swap them to get more out of the same Pi.

In this tutorial, you’ll learn how to set up a Minecraft machine on the Pi 3 from scratch. Minecraft is a fun game that lets you build whole worlds however you want, by yourself or with friends. Having your own Minecraft server gives you full control over the game.

I set up a Minecraft server because we don’t watch TV, but we have one TV in the kids’ area, and I have hooked a Pi to it so my son can play Minecraft.

In the next two tutorials, you’ll learn how to transform your Pi 3 into your own custom Netflix/Pandora-like streaming service with Plex Media Server and then how to use the Pi as a Plex media player to stream content directly to your HDMI-enabled TV.

What you need:

  1. Raspberry Pi 3

  2. HDMI enabled monitor

  3. Keyboard+mouse

  4. HDMI cable

  5. Power adapter for Pi

  6. Micro SD card (I am using 32GB capacity)

  7. Ethernet or Wireless connectivity

We are using the NOOBS distribution installer, just to make things easier for new users. Download NOOBS from the official site and extract the content. Next, plug in the micro SD card and format it as FAT32. Then copy all the extracted files to the root of the SD card. Note: Don’t copy the entire folder, copy the content of the folder.

Plug the card into the Raspberry Pi , connect the monitor via HDMI, connect the mouse/keyboard and plug in the power supply. If everything goes well, you will see the NOOBS window, where you can choose the OS that you want to install; I recommend Raspbian. Once installed, it will reboot and you are logged into your brand new Raspbian OS running on Raspberry Pi 3. Now connect the network (I recommend ethernet to get faster download speed) and update the system:

sudo apt-get update

sudo apt-get dist-upgrade

If you want you can also change the user password. The default username is pi and the password is raspberry. Change the password by typing the command, and then the new password at the prompt:

passwd pi 

Now install these packages for OpenGL Driver for improved graphics:


sudo apt-get -y install xcompmgr libgl1-mesa-dri && sudo apt-get -y install libalut0 libalut-dev && sudo apt-get -y install mesa-utils

Now it’s time to enable OpenGL drivers:

sudo raspi-config

Here you will see the option to expand the file system and change the password. We don’t need either of those because NOOBS automatically expands the file system and we have already changed the password. Skip everything and go to the advanced option.

J9bx8lw14xnFvhNZFWQb1jao8my0Fnp2QRD6hOdM

Scroll down to find AB GL Driver, hit enter and then select yes to enable. (note: the mouse won’t work, so use the arrow keys).

K3OtOgE86mrl4oOjBRDNLzP1chIdBUSWIL4shOaT

Reboot the system. Once rebooted, check if OpenGL is enabled, run ‘glxgears’ in the terminal and you should see gears turning.

Install Minecraft packages

First, we need to create directories for Minecraft:

mkdir -p ~/Minecraft/Natives

Change directory to Minecraft:

cd ~/Minecraft/

Now log into your Minecraft account and download the Minecraft.jar file for Linux to the Minecraft directory that we created. Install the launcher and log into your account:

java -jar Minecraft.jar

Click on the edit profile option and select version 1.8.9 from the list, save the profiles. If you get any error (there is a possibility of an error related to ‘execstack’), please close Minecraft and run these commands to patch some files:

cd ~/Minecraft/Natives

wget https://www.dropbox.com/s/4oxcvz3ky7a3x6f/liblwjgl.so

wget https://www.dropbox.com/s/m0r8e01jg2og36z/libopenal.so

Then update the libraries:

cd /home/pi/.minecraft/libraries/org/lwjgl/lwjgl/lwjgl/2.9.4-nightly-20150209

rm lwjgl-2.9.4-nightly-20150209.jar

wget https://www.dropbox.com/s/mj15sz3bub4dmr6/lwjgl-2.9.4-nightly-20150209.jar

Change directory to Minecraft folder:

cd ~/Minecraft/

And download the ‘run’ script:

wget https://www.dropbox.com/s/jkhr58apwa7pt1w/run.sh

Make it executable:

sudo chmod +x run.sh

Now either browse to this script from the file manager and open it by clicking on it, or run it from the terminal, and you will have Minecraft running on your machine (image below)

cd ~/Minecraft/

./run.sh

That’s it! Once it’s installed, you can start playing Minecraft on your your system. Build new worlds, invite your friends to play on your server, and keep tinkering with your new Pi 3.