Kubernetes Patterns

Kubernetes is a container orchestration platform that forms the foundation of other platforms built on top of it.

Distributed primitives. Kubernetes introduces a new set of distributed primitives for building cloud-native applications. These include Pods (groups of containers), Services (for networking and load balancing), and various controllers for managing application lifecycle. These primitives provide a higher level of abstraction compared to traditional in-process building blocks, allowing developers to focus on application logic rather than infrastructure concerns.

Declarative approach. Kubernetes adopts a declarative model where developers specify the desired state of their applications, and the platform continuously works to maintain that state. This approach simplifies application management and enables automated healing and scaling. Key Kubernetes concepts include:

• Containers: Packaged, isolated units of application code and dependencies

• Pods: The smallest deployable units, consisting of one or more containers

• Services: Stable network endpoints for accessing groups of Pods

• Labels and Annotations: Metadata for organizing and selecting resources

• Namespaces: Virtual clusters for resource isolation and multi-tenancy

To be fully automatable, a cloud-native application must be highly observable by allowing its state to be inferred so that Kubernetes can detect whether the application is up and whether it is ready to serve requests.

Predictable Demands. Applications should declare their resource requirements and runtime dependencies. This enables Kubernetes to make intelligent decisions about placement and scaling. Key aspects include:

• Resource Profiles: Specifying CPU and memory requests and limits

• Quality of Service (QoS) classes: Best-Effort, Burstable, and Guaranteed

• Pod Priority: Indicating the relative importance of Pods

Declarative Deployment. Kubernetes provides mechanisms for updating applications with minimal downtime:

• Rolling updates: Gradually replacing old Pods with new ones

• Blue-Green deployments: Switching traffic between two versions

• Canary releases: Gradually increasing traffic to a new version

Health Probes and Managed Lifecycle. Applications should implement health checks and respond to lifecycle events:

• Liveness probes: Detecting if an application is running

• Readiness probes: Determining if an application is ready to serve traffic

• Lifecycle hooks: Responding to start and stop events

The Singleton Service pattern ensures only one instance of an application is active at a time and yet is highly available.

Job Management. Kubernetes provides abstractions for managing different types of workloads:

• Batch Jobs: For running finite, completable tasks

• Periodic Jobs (CronJobs): For scheduled, recurring tasks

• Daemon Services: For running system-level services on every node

Stateful Services. Kubernetes offers StatefulSets for managing applications that require stable network identities and persistent storage:

• Ordered deployment and scaling

• Stable network identities

• Persistent storage per Pod

Service Discovery. Kubernetes provides multiple mechanisms for service discovery:

• ClusterIP Services: For internal communication

• NodePort and LoadBalancer Services: For external access

• Ingress: For HTTP-based routing and load balancing

A Sidecar container extends and enhances the functionality of a preexisting container without changing it.

Multi-Container Pods. Kubernetes allows multiple containers to be grouped into a single Pod, enabling various patterns:

• Init Containers: For initialization tasks before the main container starts

• Sidecars: For adding functionality to the main container

• Adapters: For standardizing output from heterogeneous applications

• Ambassadors: For proxying communication with external services

These patterns promote separation of concerns, modularity, and reusability in application design. They allow developers to compose complex applications from simpler, single-purpose containers while leveraging the shared context and resources provided by the Pod abstraction.

ConfigMaps and Secrets allow the storage of configuration information in dedicated resource objects that are easy to manage with the Kubernetes API.

Externalized Configuration. Kubernetes provides several mechanisms for managing application configuration:

• Environment Variables: For simple key-value pairs

• ConfigMaps: For non-sensitive configuration data

• Secrets: For sensitive information (e.g., passwords, API keys)

Immutable Configuration. To ensure consistency across environments, configuration can be packaged into immutable container images:

• Configuration containers: Dedicated images for storing configuration data

• Init containers: For copying configuration into shared volumes

Configuration Templates. For complex configurations that differ slightly between environments:

• Template processing: Using tools like Gomplate to generate configuration files

• Init containers: For processing templates during Pod initialization

These patterns enable developers to separate configuration from application code, promoting portability and reducing the risk of environment-specific issues.

An operator is a Kubernetes controller that understands two domains: Kubernetes and something else. By combining knowledge of both areas, it can automate tasks that usually require a human operator that understands both domains.

Controllers and Operators. Kubernetes can be extended to manage complex applications:

• Controllers: For implementing custom behavior based on resource changes

• Operators: For encoding domain-specific knowledge and automating complex operations

• Custom Resource Definitions (CRDs): For defining new resource types

Frameworks and Tools. Several projects facilitate the development of controllers and operators:

• Operator Framework: For building Go-based operators

• Kubebuilder: For scaffolding and managing operator projects

• Metacontroller: For implementing operators in any language

These patterns enable developers to extend Kubernetes' functionality and automate complex, application-specific operations within the cluster.

Autoscaling in Kubernetes allows us to define a varying application capacity that is not fixed but instead ensures just enough capacity to handle a different load.

Elastic Scale. Kubernetes provides multiple mechanisms for scaling applications:

• Horizontal Pod Autoscaling (HPA): Adjusting the number of Pod replicas

• Vertical Pod Autoscaling (VPA): Modifying resource requests and limits

• Cluster Autoscaling: Adding or removing nodes based on resource demand

Image Building. Kubernetes can be used to build container images within the cluster:

• OpenShift Build: An integrated system for building images using various strategies

• Knative Build: A Kubernetes-native building framework

• Daemonless builds: Tools like img, buildah, and Kaniko for rootless image creation

These patterns enable developers to create elastic, self-adjusting applications and streamline the image building process by leveraging Kubernetes' scheduling and resource management capabilities.