Using microservices and containers in network automation

A look at containers and microservices

A container is a form of OS virtualization that bundles an application with all its necessary files into one runtime environment. It is isolated from the host system. Meanwhile, microservices provide an architectural design for building a distributed application using containers. A microservice breaks applications down into smaller components.

Here is a simple breakdown of the difference between containers and microservices:

• Microservices are about the design of software.
• Containers are about packaging software for development.

Microservices and containers have revolutionized the design and deployment of applications. They have helped shift software development from a monolithic approach to a more modular and scalable one.

The adoption of microservices and containers has also affected network architecture. Distributed architecture now couples services together, enabling them to communicate with each other over the network. Resulting challenges, however, are an increase in network traffic and a need for better network management tools.

While containers have enabled developers to build scalable, lightweight and resilient applications that can be deployed across different environments, they've also led to complex and distributed network architecture.

Implement microservices and containers in network automation workflows

While containers can bring complexity to the network, they can also be used to automate networking applications and functions. Using microservices and containers in network automation brings numerous benefits, including scalability, modularity and ease of deployment.

Below are the steps to implement microservices and containers into network automation workflows.

1. Identify the microservices

Break automation tasks into smaller, independent services. Each service should handle a specific set of functions in the network, including configuration management, logging, monitoring and device discovery.

2. Containerize the microservices

Docker is the most well-known container service, but choose the right option depending on business and application needs. Ensure that each containerized microservice is lightweight and can run in multiple environments.

3. Choose APIs

Establish a set of APIs. These APIs enable the communication between microservices and data exchange. REST or gRPC are viable options for communication.

4. Choose a container orchestration tool

One of the most difficult challenges with containerization is the management of growing containers. Kubernetes can play a huge role here by providing features such as load balancing, service discovery and automated scaling, all of which are crucial for network automation.

5. Implement infrastructure as code

Implement infrastructure as code (IaC) principles to automate the provisioning and configuration of network devices. Network engineers can use a plethora of tools, such as Terraform, Ansible and Puppet, to define and manage network infrastructure in a declarative manner.

6. Adopt DevOps practices

Adopt DevOps practices to enable better collaboration between the development and operations teams. Implement continuous integration/continuous delivery (CI/CD) pipelines to automate the testing, integration and deployment of microservices. These pipelines enable a faster and more reliable release process.

Container orchestration tools and design considerations for microservices

It's crucial to select a container orchestration tool when working with containerized applications. The choice depends on application complexity, scalability requirements, team expertise and existing infrastructure.

Kubernetes is a common choice, due to its comprehensive feature set, community support and use by major cloud providers. Alternatives in the industry include Apache Mesos, Docker Swarm, HashiCorp Nomad and OpenShift.

The network remains the backbone of the digital economy. When designing microservices for networking tasks, network engineers should consider various requirements associated with networking applications. For example, the following factors are important for microservices design:

• Service granularity.
• API design.
• Network protocol compatibility.
• Security.
• Service discovery and load balancing.
• Fault tolerance and resilience.

Keep in mind: This list is not exhaustive.

Best practices for containerized networking

Containerized networking applications and services come with different advantages. Network teams can follow some best practices to enable better performance and usage of resources and performance.

Here are the best practices:

• Right-size containers. Determine the appropriate resource limit for each container by considering the requirements of the networking application. Overprovisioning of resources can lead to inefficient resource usage.
• Choose a base image. Download an image from a verified source, like Docker, to avoid vulnerabilities. Choose a lightweight base image to reduce the container size, which can result in faster deployment times for low resource consumption.
• Implement microservices architecture. Break down monolithic networking applications into smaller and separate deployable services. This improves scalability, flexibility and maintenance.
• Use a container orchestrator. Orchestration helps as the number of containers increases. It also provides features such as load balancing, autoscaling and service discovery.
• Implement health checks. The best way to know if containers are running smoothly is to implement health checks. These checks help container orchestration tools make decisions based on what is happening and perform automatic recovery when possible.

Pros and cons of microservices and containers in networking

No technology is perfect, and the same goes for microservices and containers.

Below are some of the benefits of microservices and containers in network automation:

• Scalability. Microservices architecture enables independent scaling of different components.
• Flexibility. This integration provides modularity and flexibility, giving each microservice the ability to be developed, deployed and scaled independently.
• CI/CD. CI/CD practices can be implemented in network automation. Pipelines help teams continuously integrate, test and deploy changes for faster release.
• Isolation. Containers provide isolation between microservices. These make containers powerful in network automaton because they minimize interferences and dependencies without affecting the network automation system.

Below are some of the challenges of microservices and containers in network automation:

• Security. Containers can come with vulnerabilities that cause major concerns for secure communication between microservices.
• Orchestration complexity. Tools like Kubernetes require in-depth training for teams, which can become intricate in large environments.
• Network latency. Communication among microservices can bring latency. Teams must have a strategy when designing microservices for better performance.
• Compliance and data security. Different environments require different data protection strategies and regulations. This can be challenging in situations that require encryption and access control for sensitive information.
• Legacy integration. It can be challenging to integrate containers and microservices with legacy architecture.

Verlaine Muhungu is a self-taught freelance network technician. He was recognized as a Cisco top talent in sub-Saharan Africa during the 2016 NetRiders IT Skills Competition.