virtualization

Read­ing Time: 5 min­utes

If it’s true that a pic­ture is worth a thou­sand words, then nascent soft­ware com­pa­ny Uila has writ­ten a nov­el with their break­out soft­ware prod­uct for mon­i­tor­ing, and per­form­ing root cause analy­sis on, vir­tu­al­ized and phys­i­cal net­work infra­struc­ture, bridg­ing the gap between both. Rarely does a break­through prod­uct come out of a start­up on first try—usually there is much refining—but Uila may have done just that. The visu­al­iza­tions are noth­ing short of stun­ning, and the back­ing data is attained fast, and is high­ly accu­rate. Add cloud man­age­ment and you real­ly do have the mak­ings of a great prod­uct.

Before we get to the prod­uct, how­ev­er, in this case it is worth talk­ing for a moment about the founders of Uila. Chia-Chee Kuan, Dean Au, and Miles Wu have, col­lec­tive­ly, some 76 years of expe­ri­ence between them in the indus­try they’re try­ing to change; expe­ri­ence that comes in the form of patents, in the found­ing of com­pa­nies like Air­Mag­net and Cin­co Net­works, and in the many years of R&D at com­pa­nies from Cis­co to Fluke. Oh, and let’s not over­look their cre­den­tials in the form of com­put­er sci­ence degrees and master’s degrees from some of the best engi­neer­ing schools across the world. Back­ground and expe­ri­ence do not equal suc­cess, but cer­tain­ly the weight of expe­ri­ence here lends itself to a high lev­el of cred­i­bil­i­ty right out of the gate, and begs at least a sec­ond glance.

What’s the Prob­lem?

As data cen­ters and infra­struc­ture in gen­er­al have become increas­ing­ly com­pli­cat­ed, the risk of one thing break­ing and caus­ing the whole ball of yarn to come undone has increased expo­nen­tial­ly, while the tools to ana­lyze such prob­lems with an eye towards root cause analy­sis and res­o­lu­tion have not matured. Ven­dors are still sell­ing, and users are still using, point prod­ucts designed to trou­bleshoot one par­tic­u­lar aspect of a fail­ure. What we should be doing is not iso­lat­ing fail­ure domains from a trou­ble-tick­et point of view, but rather start­ing with a larg­er domain and shrink­ing from there. It’s a dif­fer­ent method­ol­o­gy, but in today’s data cen­ters it can be chal­leng­ing to go with the tra­di­tion­al bot­tom up tech­niques we’ve all learned to love.

Don’t take that to mean that we should­n’t use good, sol­id meth­ods for iso­la­tion of fail­ures, just that we should be doing so on sub­sets of the larg­er whole, with that larg­er whole firm­ly vis­i­ble and watched as we work. Too often we toss flam­ing bags of shit over the wall to the <insert team here> and hope that they fig­ure out the prob­lem (val­i­dat­ing that the prob­lem was theirs to fix) before toss­ing it back. In this way, each team in suc­ces­sion, goes through the insu­lar trou­bleshoot­ing steps rel­e­vant to only their domain, with no inter­est in, or view of, the big­ger whole. This is inef­fi­cient and slow, and a ter­ri­ble way to solve any prob­lem.

How Does Uila’s Prod­uct Work?

Uila’s prod­uct aims to bridge those inher­ent divides in trou­bleshoot­ing and appli­ca­tion vis­i­bil­i­ty spheres by uti­liz­ing vir­tu­al smart taps (vST) in con­cert with more tra­di­tion­al (SNMP, SMI, SSH) means. Vir­tu­al taps get their infor­ma­tion straight from the dis­trib­uted vir­tu­al switch (DVS) in a vir­tu­al­ized envi­ron­ment, and uti­lize agents to grab the phys­i­cal device data. All of this gets rolled up to the Uila Man­age­ment & Ana­lyt­ic Sys­tem, which is a cloud-based ser­vice han­dling the intel­li­gence and analy­sis behind and of the data–think: Mer­a­ki for appli­ca­tion vis­i­bil­i­ty.

Uila’s prod­uct can per­form deep pack­et inspec­tion (DPI), auto-dis­cov­er over 4000 appli­ca­tions, track appli­ca­tion trans­ac­tions and depen­den­cies, and track net­work and TCP per­for­mance all while remain­ing dis­trib­uted and agent-less. For a lot of sys­tems and net­work oper­a­tors the lat­ter point is a big one. Hav­ing to install agents on a mul­ti­tude of devices, many of which can’t actu­al­ly host agents, can become unwieldy. An agent-less prod­uct like Uila’s allows for a quick­er roll­out over­all, mak­ing for a quick­er time to val­ue for the busi­ness. And because of the var­i­ous inflec­tion points for data into the appli­ca­tion, full stack vis­i­bil­i­ty is more than just lip-ser­vice.

What Else Can It Do? 

One of the chal­lenges of mod­ern soft­ware-defined net­work­ing, sys­tems, cloud, etc., is appli­ca­tion dis­cov­ery map­ping. Assum­ing that one of the pri­ma­ry rea­sons for mov­ing to a new modal­i­ty in net­work fab­rics and automa­tion is agili­ty, under­stand­ing what the hell your appli­ca­tions are doing is of para­mount impor­tance. Under­stand­ing which ports are used by which process­es, which back­end data­bas­es talk to which front-end or mid­dle-ware soft­ware ser­vices, and how all of this can be orches­trat­ed and auto­mat­ed is not as easy as it might appear at first glance. Find­ing this infor­ma­tion can be frus­trat­ing and error-prone, and very often depen­den­cies get missed, lead­ing to down­time, roll-backs, or missed mile­stones.

Uila’s soft­ware, due to it’s full-stack vis­i­bil­i­ty, is actu­al­ly a very good tool for ana­lyz­ing a soft­ware stack, for per­form­ing appli­ca­tion depen­den­cy map­ping at a fast clip and with high accu­ra­cy and con­fi­dence. Hav­ing used a vari­ety of tools to per­form this analy­sis in the recent past, I can say that this tool is one of the best on the mar­ket. The visu­al­iza­tions are a nice touch, as dur­ing these exer­cis­es I have found that many appli­ca­tion teams are sur­prised to learn the com­plete scope of what their stack is doing, rein­forc­ing the fact that a tool like this is key to grab­bing all per­ti­nent infor­ma­tion pos­si­ble.

Con­clu­sions, More Infor­ma­tion, and Next Steps

In watch­ing the pre­sen­ta­tion that led to this arti­cle, research­ing the prod­uct online, using the prod­uct myself, and talk­ing with the founders in per­son, one thing has become abun­dant­ly clear to me: this appli­ca­tion has a lot more capa­bil­i­ties and fea­tures than I can prop­er­ly cap­ture in a sin­gle sit­ting. Stor­age ana­lyt­ics, vir­tu­al machine (VM) cross-talk, laten­cy and jit­ter, and myr­i­ad more options for trou­bleshoot­ing are all cov­ered through this tool, and the uses are lim­it­ed only by the time you have to delve in and push but­tons. I haven’t even brought up the auto­mat­ed root cause analy­sis capa­bil­i­ties, which in and of them­selves war­rant at least an arti­cle, if not a whitepa­per.

 

If you have any inter­est in the prod­uct, I would sug­gest you take a look at Uila’s web­site (http://www.uila.com) and poke around a bit. They have an impres­sive list of cus­tomers already, as well as some whitepa­pers and oth­er infor­ma­tion avail­able. They have a gen­er­ous 30-day free tri­al which is ful­ly fea­tured and includes sup­port and train­ing, which goes a long way to get­ting peo­ple in and using the prod­uct in enough time to actu­al­ly use the demo—something some more estab­lished indus­try play­ers might want to take note of. You can also see some videos of Uila pre­sent­ing their solu­tions to an audi­ence of indus­try folks of vary­ing back­grounds, by going to the Tech Field Day site at: http://techfieldday.com/companies/uila/.

At the end of the day, Uila may have writ­ten a nov­el, but the mar­ket will deter­mine if it’s worth read­ing.