Microservices on Kubernetes: Key Patterns and Cloud‑Native Insights

Speaker and Session Overview

Yang Le, co‑founder of Shisu Cloud, presented an online session titled “Microservices and Container Cloud Platform,” sharing technical insights on building micro‑service‑based applications on Kubernetes.

What Is a Microservice?

Microservices are loosely defined but essentially consist of a collection of small, independent services that each run in its own process and communicate via lightweight protocols such as HTTP/REST. Each service encapsulates a specific business capability, is deployed automatically, can be scaled independently, may be written in different programming languages, and is maintained by a dedicated team.

Although the term is newer, the concept builds on Service‑Oriented Architecture (SOA). Unlike traditional monolithic libraries that require whole‑system redeployment, microservices enable partial updates without affecting the entire system, though they introduce cross‑process boundary considerations such as fault tolerance and clear responsibility definitions.

Containers, DevOps, and Microservices

Container technology has driven a DevOps transformation by offering lightweight, fast‑deployment, and portable environments. While containers simplify testing, deployment, and upgrades, they also integrate development into the product delivery pipeline, aligning with DevOps goals of continuous integration, delivery, and stability.

Key Questions for Adopting Microservices

How frequently are services upgraded, and can upgrades be performed without downtime?

When adding new features, is a full redeployment required, and does it risk interrupting existing functionality?

What proportion of failures stem from code bugs versus deployment or operational errors?

Can critical components scale horizontally as user demand grows?

If high upgrade frequency, zero‑downtime requirements, and scalability are needed, microservices become a compelling choice.

Microservice Design Patterns

1. Ambassador Pattern

This pattern introduces a proxy sidecar that abstracts access to an external service (e.g., Redis). Instead of embedding Redis connection logic throughout the web application, the web app communicates with an Ambassador proxy, which forwards requests to Redis. This reduces coupling and eases Redis replacements.

2. Sidecar Pattern

A sidecar container runs alongside the main service to provide auxiliary functions such as log collection, monitoring, or automatic code synchronization. For example, a logging sidecar can ship logs to a central server, while a monitoring sidecar tracks service health.

3. Adapter Pattern

The adapter pattern enables a service to operate across multiple cloud environments (e.g., AWS, Alibaba Cloud) by abstracting vendor‑specific APIs. A monitoring service can adapt to each IaaS provider’s API, allowing unified log collection and health checks while keeping the core service unchanged.

Kubernetes Foundations

Kubernetes is a cluster‑level container orchestration system originating from Google’s Borg project. It organizes workloads into three logical layers:

Pod : the smallest deployable unit, grouping one or more containers that share network and storage.

ReplicationController (or Deployment) : manages pod replicas, providing elastic scaling.

Service : a stable network endpoint that load‑balances traffic across pod replicas via a proxy.

Kubernetes supports various networking models and distributed storage solutions, though it does not solve multi‑node networking by itself.

Mapping Patterns to Kubernetes

Because pods share an IP address and network namespace, implementing the Ambassador pattern is straightforward: the proxy runs in the same pod as the main service and communicates via localhost, avoiding external exposure. Sidecar containers naturally coexist in the same pod, sharing lifecycle and resources, which simplifies log collection or monitoring. The Adapter pattern benefits from Kubernetes’ ability to run multiple pods across different cloud providers, each with its own configuration, while a central controller orchestrates deployments.

Shisu Cloud’s Container Support

Shisu Cloud extends Docker Compose‑style YAML definitions to describe multi‑container applications, leveraging Kubernetes controllers to maintain service availability and enable seamless scaling.