When it comes to building server-side applications, there are typically two approaches: monolithic and microservices. A monolithic architecture is built as a single system, typically using the same code base. A system like this is easier to develop, test and deploy – by pushing it out all at once. Many of the large successful applications that run as the backbone of today’s enterprises started out as monoliths. This approach, however, has a number of serious limitations. Because the layers such as the business logic, application and database access are all tightly bundled together, and all traffic flows through static, defined patterns, monolithic systems become increasingly complex and difficult to manage. Changes to any of the layers require configuration changes to the entire infrastructure, and it’s hard to understand the impact of the change on each layer and component, leading to extensive additional testing and deployment delays. Continuous deployment and continuous integration are near-impossible with monolithic applications, and so is adoption of new technologies and architectures, such as development of cloud-native applications. In the world where enterprises strive to respond quickly to changing market conditions and customer demands, DevOps teams are increasingly looking to more modular, loosely coupled architectures, where individual services can function as independent, interconnected units.
Each microservice is a small application with its own set of capabilities that are usually independently deployable. Microservices allow for faster delivery of applications and make deployments more flexible and agile. Since each application is a collection of independent units, traffic to the application flows through dynamic, distributed paths. So, to make changes or introduce new service capabilities or feature sets, you no longer need to shut down the entire system – changes made to one unit/module don’t affect other parts of the application.
Among the primary drivers for application microservices are hyper scalability, rapid development and delivery, flexibility, distributed ownership, and failure isolation and fault tolerance – when individual instances of a microservice application instance fail, they are easily redirected to available instances.
Microservices Architecture and the Network
The benefits of smaller, more agile microservices are hard to ignore, but enterprises need to understand that transitioning from monolithic application development to microservices is going to introduce new challenges to their networks. Keeping track of the numbers, health, and performance of microservices is not easy and managing all the network components that support them can become a daunting task.
Applications service instances interact with the network infrastructure on an on-demand basis. A change in the application traffic patterns introduces more East/West bound traffic – North/South traffic flows in and out of the network (common in monoliths), whereas East/West traffic is moving laterally inside the network.
This distribution of service instances introduces the need for load balancing services, which in turn can lead to high latency in processing requests. Additionally, the DNS, load balancers and firewalls need to be updated every time a service instance is created, updated or removed.
Overcoming the Network Challenge
Central service discovery
The key to keeping up with the rapid adoption of microservices is having a centralized service discovery mechanism that’s able to dynamically detect and connect services – on an application-centric basis – across on-premise and cloud infrastructures. DevNetOps teams need to be able to dynamically discover where services have been deployed, where they are active, which firewall policies are associated with each application instance, which load balancers are in use, which certificate instances are needed for encrypted traffic, how IP addresses are allocated, and even which items under their ITSM are being created to keep track of configuration requests and their progress.
Central service monitoring
To track the health and performance of microservices during run-time, organizations need central monitoring – the ability to detect the state and status of all services from the application-centric point of view. It is also extremely valuable to extend service capabilities to application administrators to allow them to initiate necessary network configuration changes to support application deployments and upgrades.
Central failover policy
Application teams that use microservices can benefit from having a central failover policy that facilitates random load balancing to reduce latency.
Automatic updates for key network components
Having tools that automatically provide required updates to load balancers, DNS, and firewall security policies every time new application services are added or removed ensures that changes and new features can be rolled out smoothly and without interruption.
AppViewX Delivers Network Automation to Support Microservices Deployments
AppViewX is a low-code NetOps and DevSecOps orchestration platform. It provides modular, intuitive, context-ware automation for application services and networks across multi-vendor, hybrid-cloud environments. AppViewX discovers and manages all network devices in the context of the overall infrastructure, including their state, status, health, and performance.
For configuration and deployment of the microservice application instances, AppViewX offers the flexibility of automatic orchestration using visual workflows. NetOps and NetDevOps teams can configure traffic management policies on load balancers and firewalls to dynamically enact failover, in case a service goes offline, using the code-free Visual Workflow builder or through the integration of third-party configuration management tools, like Ansible, Chef, or Puppet.
AppViewX provides an application centric topological view of the network infrastructure, microservices, their interconnections and traffic flows. You can not only identify which devices the traffic flows through, but also the state and status of each device, and the ability to interact with these platforms for troubleshooting.
Network Automation with AppViewX
Network automation begins with discovery – taking the infrastructure and integrating it with the AppViewX platform, so it can discover, from the application-centric perspective, all relevant network components and configurations in your data centers.
Following discovery, we recommend progressing to the management phase to identify and manage the multi-vendor and hybrid infrastructure from a visual view.
Third is the design of automation, which lets you apply repeatable deployment strategies for each network component.
Finally, you can use AppViewX to automate network service requests from a catalog of available workflows, creating a consistent and dependable process that can be used across the organization.
As microservices continue to gain popularity, organizations need to consider the impact they might have on their networks’ configuration and performance. Simply building applications using small, flexible components does not guarantee business agility. Organizations need to have systems in place for network automation and orchestration that would allow them to deploy microservices at high volume across multi-vendor, hybrid infrastructures. By using a low-code context-, configuration-, and state-aware system like AppViewX, that are also equipped with reusable visual workflows, organizations can fully realize the benefits of microservices architecture and improve their responsiveness to customer demands, speed, and time to market.
Learn more about AppViewX Network Automation and Orchestration platform and contact us to schedule a demo today.