Anyone who has dealt with critical infrastructure can tell at least one story of their own, proving Murphy’s law correct: “whatever can go wrong, will go wrong.”
Complex systems are more difficult to maintain and as a result more prone to outages. So there is always desire amongst network and systems architects to design “simple” answers for problems. Often times it is easier said than done. In software development and systems architecture, the first solutions that come to mind are typically the most complex ones. It takes engineering brilliance and a lot of experience to be able to deconstruct a complex architectural design down to a simple solution. Ray Ozzie (ex-Chief Software Architect at Microsoft) said it nicely: “Complexity kills. It sucks the life out of developers, it makes products difficult to plan, build and test, it introduces security challenges, and it causes end-user and administrator frustration.”
You can see the same design traits in other industries as well, for example in watchmaking. I am a watch geek, fascinated by the brilliance of master watchmakers and the clever approaches they take in designing a miniature mechanical machine that works flawlessly and continuously for years.
I came to know one particular watchmaker that has the same “simple design” principle. Dr. Ludwig Oechslin is the master watchmaker behind Lucerne-based watch company ochsundjunior.swiss. He believes having more parts in a watch means more things that can go wrong, so he designed the world’s simplest perpetual calendar watch. A perpetual calendar watch accounts for leap years and displays the correct date. Conventional perpetual calendar functions are executed in levers and springs, are delicate to handle, and are comprised of numerous parts (Patek Philippe uses 182) but Ludwig’s perpetual function is made of just 9 gears!
When we started designing core components of Tesuto’s platform, “simplicity” and “scalability” were key design attributes in our minds. We wanted to make sure that our product is simple and easy to use for our customers. At the same time we worked to reduce the number of core components of our system to ensure it is easy for us to maintain and extend our solution as networks evolve.
Today we are publishing our API documentation.
Please take a moment to look at api-docs.tesuto.com and see for yourself how easy it is to describe networks in Tesuto regardless of size and complexity.
Here are some aspects of Tesuto’s platform with “simplicity” in mind:
- No production access required: All that is necessary for creating an emulated device in Tesuto’s’ platform is your configuration and topology. That’s it! We don’t need to have access to or communication with your production network or even collect any state from your network.
- Easy configuration: Device configurations are uploaded to emulated devices in their native format, and the topology is defined using a simple 4 tuple structure. (And yes, you can remove your encrypted login credentials, potential customer names or community strings. We don’t need them for emulation. In other words, you can assure your legal and security teams; working with Tesuto does not pose any PII exposure risk.)
- Security: Device configuration and topology are stored in an encrypted format in our system.
- Powerful validation out of the box: Tesuto has a fully-loaded library of validators so you get the power of Tesuto’s validation the moment you sign up with no need to develop complex validators.
- Vendor agnostic validation framework: Customers configure a generic validator and Tesuto takes care of all vendor dependent parts behind the scenes.
- Intuitive UI: We will have a future blog post dedicated to our UI.
- Easy integration to your continuous integration and delivery pipeline: Our APIs allow you to easily integrate Tesuto’s validation cycle in your CI/CD.
Building a “simple” solution should not limit “scalability” of the platform. Here are a few notable points about Tesuto’s scalability:
- Horizontal scaling emulation: Emulated nodes spin up in parallel so if you have just a couple of network devices or thousands of them, initialization time is approximately the same.
- Rapid initialization: We have done lots of work to reduce initialization time of emulated devices. Tesuto can resume previously-emulated devices in under a minute.
- Cloud-agnostic: Emulation is a resource-intensive process. Emulated routers of major network vendors need several gigabytes of memory at a minimum per instance. We designed our solution to be cloud agnostic. This allows us to deploy to a customer’s private cloud if they prefer.
- Physical device augment: We have the ability to augment emulated environment and allow physical devices to be included in verification.
- Virtual servers for end-to-end application testing: This feature allows our customers to include their applications in an emulated network, and test end to end functionality when validating network changes.
Modern networks are very complex but your validation framework does not have to be. We built a simple to use and scalable platform to quickly validate intended changes before they are applied to a production network. If you are interested in test driving Tesuto, you can request a demo here.