Understanding Kubernetes

Objective

After completing this lesson, you will be able to explain Kubernetes, its cluster architecture, and describe the purpose of its core objects: Pod, Deployment, Service, and Namespace.

Introduction

Lesson 3.1 established that containers solve the packaging problem - but not the management problem. Who decides where each container runs, restarts it when it fails, scales it under load, and coordinates updates across dozens of components simultaneously? For Global Manufacturing AG, whose EIC deployment on the SUSE Rancher RKE2 cluster in Frankfurt consists of many cooperating containers, this question is not theoretical - it is an immediate operational concern. This lesson introduces the platform that answers it.

The Need for Orchestration

Containers solve the problem of packaging applications consistently. But in a production environment, you do not run one or two containers - you might run dozens or hundreds, spread across multiple servers, that need to communicate with each other, scale in response to demand, recover automatically from failures, and be updated without downtime.

Managing this manually would be impractical and error-prone. Consider the questions that arise immediately if Global Manufacturing AG were to run EIC on a single server with manually started containers:

  • Availability: What happens if that server fails? Integration between S/4HANA and the QMS halts.
  • Scaling: What if message volume spikes during a production campaign? There is no easy way to add capacity.
  • Updates: How do you update EIC components without service interruption?
  • Distribution: As more containers are added, how do you decide which server runs which container?
  • Health monitoring: If a container crashes at 3:00 in the morning, who restarts it?

Managing these concerns manually becomes untenable at any meaningful scale. This is the orchestration problem - and Kubernetes was designed precisely to solve it.

What Is Kubernetes?

Kubernetes (often abbreviated as K8s, where "8" replaces the eight letters between "K" and "s") is an open-source system for automating the deployment, scaling, and management of containerized applications.

Kubernetes was originally conceived by engineers at Google in 2013, inspired by Google's internal cluster management system called Borg - which had managed container workloads at massive scale within Google since the early 2000s. Google open-sourced the Kubernetes project in June 2014. In 2015, Google and the Linux Foundation co-founded the Cloud Native Computing Foundation (CNCF), with Kubernetes as its seed technology. Kubernetes has since become the de facto standard for container orchestration, with support from every major cloud provider and a large open-source community.

The Declarative Model

Kubernetes introduces a critical concept: the declarative model. Instead of issuing imperative commands ("start this container on that server"), you declare the desired state of your system: "I want three replicas of this application running at all times." Kubernetes then continuously works to make the actual state match the desired state - restarting failed containers, scheduling workloads on healthy nodes, and scaling as configured.

This is fundamentally different from traditional server administration, where an administrator manually starts, stops, and monitors processes. With Kubernetes, the system actively maintains the state you defined - automatically and continuously.

For EIC operators, this means: once EIC is deployed and running correctly, Kubernetes actively maintains that state. Your operational responsibility shifts from "keep things running" to "define what running correctly means" - and let Kubernetes enforce it.

Kubernetes Cluster Architecture

A Kubernetes deployment is called a cluster. A cluster consists of one or more Control Plane nodes and one or more Worker Nodes.

Overview of Kubernetes control plane and nodes.

The Control Plane

The Control Plane is the brain of the Kubernetes cluster. It makes global decisions about the cluster - scheduling workloads, detecting and responding to cluster events - and exposes the Kubernetes API. The Control Plane typically runs on dedicated nodes separate from application workloads.

Key Control Plane components:

ComponentRole
API ServerThe front door of the Kubernetes API; all interactions with the cluster - whether from administrators, automation tools, or other components - go through this component
etcdA distributed key-value store that holds the authoritative cluster state - all Kubernetes objects and their current state are stored here
SchedulerWatches for newly created Pods with no assigned node and selects a node for them based on resource availability and constraints
Controller ManagerRuns controller processes (Deployment Controller, Node Controller, etc.) that monitor actual state and drive it toward desired state

Worker Nodes

Worker Nodes are the machines in the cluster where containerized applications actually run. Each worker node contains:

ComponentRole
kubeletAn agent that runs on each node, ensuring containers are running in their Pods as directed by the Control Plane
kube-proxyMaintains network rules on the node for Pod communication
Container RuntimeThe software that executes containers (for example, containerd - introduced in Lesson 3.1)

Worker nodes can be physical servers, virtual machines, or cloud instances. In a production EIC deployment, you typically have multiple worker nodes for high availability and load distribution.

Note the connection to Lesson 3.1: the Container Runtime on each Worker Node is the same concept you already learned - it pulls images from a Container Registry and starts containers. Kubernetes automates when and where this happens.

Core Kubernetes Objects

Kubernetes manages applications through a set of objects - persistent entities that represent the desired and actual state of your cluster. Understanding the most important objects is essential for understanding how EIC works.

Pod

A Pod is the smallest deployable unit in Kubernetes. It represents one or more containers that are tightly coupled and should run together on the same node. Containers within a Pod share:

  • A network namespace: they share the same IP address and can communicate with each other via localhost
  • Storage volumes: they can access the same persistent data mounts

Pods are ephemeral - they are not designed to be long-lived. If a Pod fails, Kubernetes replaces it with a new one. This design encourages stateless application architecture and is a direct extension of the container ephemerality introduced in Lesson 3.1.

Analogy: Continuing the building analogy from Lesson 3.1 - if a container is an apartment, a Pod is the apartment unit including its shared address. Multiple containers can share one Pod, communicating via local host. But the Pod itself can be terminated and replaced - like vacating a unit and assigning a new tenant to the same address.

Deployment

A Deployment is a higher-level object that manages a set of identical Pods. You describe the desired state - for example, "run three replicas of this container image" - and the Deployment Controller continuously works to achieve and maintain that state.

Deployments handle:

  • Rolling updates: Update containers progressively, replacing old Pods with new ones without downtime
  • Rollbacks: If an update fails, revert to the previous version automatically
  • Self-healing: If a Pod crashes, the Deployment Controller immediately starts a replacement Pod

In practice, you rarely create Pods directly - you create Deployments, and Deployments manage the Pods for you.

This is the declarative model in action: you declare "three replicas," and Kubernetes maintains that reality - regardless of node failures, container crashes, or hardware changes.

Example: If a Deployment specifies three replicas of the EIC Worker Pod, and a node failure takes one Pod offline, Kubernetes automatically schedules a replacement on a healthy node - without any manual intervention. This happens within seconds.

Service

A Service provides a stable network identity for a set of Pods. Because Pods are ephemeral and their IP addresses change when they are replaced, you cannot rely on a Pod's IP address for reliable communication. A Service provides:

  • A stable cluster-internal IP address (ClusterIP) and DNS name
  • Load balancing across multiple Pod replicas
  • A consistent access point that remains stable even as underlying Pods are replaced

Service types include:

TypeDescriptionEIC Relevance
ClusterIP (default)Accessible only within the clusterUsed for internal EIC component communication
NodePortAccessible on a static port on each nodeTypically for development only
LoadBalancerCreates an external load balancer (on cloud providers) or virtual IP (on-premise), making the Service accessible from outside the clusterUsed by EIC to expose its HTTPS integration endpoint to on-premise source systems

Namespace

Namespaces provide a mechanism for logically dividing cluster resources among multiple teams or applications. They provide:

  • Resource isolation: Resources in one namespace are not visible in another by default
  • Name scoping: Two resources with the same name can exist in different namespaces without conflict
  • Access control: Role-Based Access Control (RBAC) permissions can be applied per namespace

Important for EIC: SAP Edge Integration Cell is deployed into a set of Kubernetes namespaces. By default, the primary namespace is edge-icell. Namespace names can be configured, and multiple EIC instances can be deployed within a single Kubernetes cluster, each using its own distinct set of namespaces.

Scenario Check-In: Global Manufacturing AG

Global Manufacturing AG's SUSE Rancher RKE2 cluster in the Frankfurt data center - selected in Unit 2, Lesson 2.4 and prepared for deployment in Unit 2, Lesson 2.6 - is a Kubernetes cluster in the architecture you just learned: a Control Plane manages the cluster state, while multiple Worker Nodes run the actual workloads.

When Edge Lifecycle Management deploys EIC to this cluster, it creates Kubernetes Deployments for each EIC component - the integration runtime, the API policy engine, the message service. Each Deployment manages one or more Pods, and Kubernetes ensures the desired number of replicas is always running. If a Worker Node in Frankfurt fails during a night shift, Kubernetes automatically reschedules the affected Pods to a healthy node - the orchestration problem from the beginning of this lesson, solved without manual intervention.

All EIC resources are placed in the edge-icell namespace, logically isolated from any other applications on the same cluster. A LoadBalancer Service exposes EIC's HTTPS integration endpoint so that S/4HANA and the QMS can send messages to EIC within the private Frankfurt network.

The infrastructure team does not start or stop containers manually. They defined the desired state - through ELM and the Kubernetes Deployments - and Kubernetes maintains it.

Key Takeaways

Containers package applications consistently, but managing many containers across multiple servers requires automation. This is the orchestration problem: ensuring availability, scaling, updates, workload distribution, and health monitoring at scale.

Kubernetes is an open-source container orchestration platform, originally inspired by Google’s internal Borg system and open-sourced in 2014. Its core principle is the declarative model: operators define the desired state, and Kubernetes continuously drives the actual state to match - restarting failed containers, scheduling workloads, and scaling as configured.

A Kubernetes cluster consists of a Control Plane (API Server, etcd, Scheduler, Controller Manager) that makes scheduling and state decisions, and Worker Nodes (kubelet, kube-proxy, Container Runtime) where containers actually run. Core Kubernetes objects relevant to EIC are:

ObjectRole
PodSmallest deployable unit - one or more tightly coupled containers sharing network and storage
DeploymentManages identical Pod replicas with self-healing, rolling updates, and rollbacks
ServiceStable network identity and load balancing for a set of ephemeral Pods
NamespaceLogical isolation of cluster resources with scoped access control

EIC is deployed in the fixed namespace edge-icell. Only one EIC instance per cluster is supported.

In Lesson 3.3, you will see how EIC’s specific components map to these Kubernetes objects and how the full runtime architecture is organized inside the cluster.

Further Resources

Kubernetes.io – What is Kubernetes?

https://kubernetes.io/docs/concepts/overview/

Kubernetes.io – Cluster Architecture

https://kubernetes.io/docs/concepts/architecture/

SAP Help Portal – Technical Landscape for Edge Integration Cell

https://help.sap.com/docs/integration-suite/sap-integration-suite/technical-landscape-edge-integration-cell