Understanding Containers

Objective

After completing this lesson, you will be able to explain containerization, its differences from virtual machines, core container concepts, and their role in SAP Edge Integration Cell.

Introduction

In Units 1 and 2, you established a solid understanding of why SAP Edge Integration Cell (EIC) exists and how its hybrid architecture separates cloud-based management from private, local execution. You also learned that EIC runs on a customer-managed Kubernetes cluster, with Kubernetes forming part of the operational responsibility of the customer’s infrastructure team.

But what does it actually mean for EIC to run on Kubernetes?

Kubernetes manages containerized workloads, and containers are the fundamental building blocks from which the EIC runtime is assembled. Understanding EIC at an operational level therefore starts with understanding what containers are, why they are used, and how Kubernetes manages them.

This unit builds that foundation step by step. You will first explore containerization and the core concepts of Kubernetes. You will then apply those concepts directly to EIC by examining how its runtime components map to Kubernetes workloads and supporting services. Finally, you will follow a single integration message through the EIC cluster, from its arrival at the runtime to processing, delivery, and monitoring.

By the end of the unit, Kubernetes will no longer be just an infrastructure prerequisite for EIC. You will be able to connect its concepts directly to the way EIC is deployed, operated, and observed.

The Challenge of Environment-Dependent Software Behavior

Before containerization became mainstream, software teams faced a recurring problem: an application worked perfectly in a developer’s local environment but failed when deployed to a test or production system.

The cause was often not the application itself, but subtle differences between environments: a different version of a shared library, a changed operating system configuration, a missing dependency, or an environment variable that had been set locally but never documented.

This problem is commonly summarized as "It works on my machine." In enterprise environments, however, its consequences can be significant:

  • Delayed deployments and longer release cycles
  • Defects that are difficult to reproduce outside production
  • Significant effort spent on environment setup and troubleshooting
  • Manually configured server environments that become increasingly difficult to reproduce or rebuild

The underlying issue is environment dependency: software does not run in isolation. Its behavior depends on the operating system, libraries, runtime, configuration, and other components of its execution environment.

Traditional approaches such as detailed setup documentation, standardized server configurations, and virtual machine images reduced these inconsistencies, but they did not remove them entirely.

Containerization addresses this problem by packaging an application together with the components it needs to run into a standardized, portable unit.

Virtual Machines vs. Containers

To understand containers, it helps to understand how they differ from the technology that preceded them: Virtual Machines.

Virtual Machines

A Virtual Machine virtualizes the entire hardware stack. A layer of software called a hypervisor (for example, VMware ESXi, Microsoft Hyper-V, or KVM) runs on top of the physical host hardware. On top of the hypervisor, each VM runs its own complete guest operating system (OS) - including its own kernel, libraries, and system services. The application runs on top of this guest OS.

Analogy: A VM is like a separate detached house built on a shared piece of land. Each house has its own foundation, walls, roof, heating system, plumbing, and electrical system - completely independent from its neighbors. The construction overhead is high, but the isolation is absolute.

VMs provide strong isolation. However, running a full guest OS for each application carries significant overhead:

  • Each VM typically consumes gigabytes of disk space for the OS image alone
  • VMs take minutes to start - the guest OS must boot fully before the application is available
  • CPU and memory consumed by running multiple full operating systems reduce the capacity available for actual application workloads

Containers

Containers take a fundamentally different approach. Instead of virtualizing the hardware, containers virtualize the operating system. They share the host OS kernel, but each container packages the application and its dependencies - libraries, binaries, configuration files - into an isolated, portable unit.

Analogy: A container is like an apartment in a building. All apartments share the same building structure (the host OS kernel) and core infrastructure. But each apartment is self-contained, with its own furniture, layout, and configuration (the application and its dependencies). The apartments are isolated from each other, but the building is used far more efficiently than if each resident built a separate house.

This shared-kernel approach makes containers dramatically more efficient than VMs:

  • Containers typically start in seconds rather than minutes
  • A container requires megabytes of overhead, not gigabytes
  • Many more containers can run on the same hardware compared to VMs

The key distinction: Virtual Machines virtualize hardware. Containers virtualize the operating system. This difference makes containers lighter, faster, and more portable - though it also means they share the host kernel, which is an important security consideration in multi-tenant environments.

Virtual Machines vs. Containers

Core Concepts of Containerization

Several foundational concepts underpin container technology. Understanding these precisely is essential for working with Kubernetes and EIC.

Container Image

A Container Image is a lightweight, standalone, executable package that contains everything needed to run an application: the application code, its runtime environment, system libraries, configuration files, and any other dependencies.

Container images are immutable - once built, they do not change. This immutability is a critical property: it guarantees that the same image will produce the same running application regardless of where and when it is started.

Images are composed of layers. Each layer represents a discrete change - installing a library, copying application code, setting an environment variable. Layers are shared across images wherever possible, reducing disk usage and download time. When a new version of an application is built, only the layers that changed need to be rebuilt or re-downloaded.

Practical example: A container image for a Java application might contain:

  • A base layer: a minimal Linux operating system
  • A second layer: the Java Runtime Environment (JRE)
  • A third layer: the compiled application JAR file and its configuration

Every time this image is started, it produces a container running this exact combination - on any machine with a compatible container runtime.

Container images are typically built from a Dockerfile - a text file containing instructions that specify how to assemble the image. A Dockerfile makes the image build process reproducible and version-controlled. Anyone with the Dockerfile and its inputs can build the same image.

Note

Docker is the technology that popularized containers. While the container ecosystem has evolved, Docker-originated concepts - such as the Dockerfile format - remain industry-standard.

Note

For SAP software such as EIC, SAP builds and provides the container images. As an operator, you do not write Dockerfiles for EIC - you consume the pre-built images from SAP's container registry. Understanding images remains essential, however, for understanding how EIC components are deployed and updated.

Container Registry

A Container Registry is a storage and distribution service for container images. After an image is built, it is pushed to a registry. Any system that needs to run the image pulls it from the registry. Public registries (such as Docker Hub) host open-source images; organizations use private registries to store proprietary images with access control.

For EIC: SAP publishes all EIC container images to SAP's own container registry. When Edge Lifecycle Management deploys or updates EIC on your Kubernetes cluster, it pulls the required images from this registry. Network access from the cluster to the SAP container registry is a deployment prerequisite (as covered in Unit 2, Lesson 2.6).

Container Runtime

The Container Runtime is the software responsible for pulling container images from a registry, starting containers from those images, managing their lifecycle, and enforcing isolation. Examples include:

  • Containerd - the most widely deployed container runtime, used by Kubernetes in production environments
  • Docker Engine - familiar to most developers; internally uses containerd as its core runtime

The container runtime handles the low-level operating system mechanisms that provide isolation: Linux namespaces (for process, filesystem, and network isolation) and control groups, or cgroups (for resource limits such as CPU and memory).

Container

A Container is a running instance of a Container Image. The relationship between an image and a container is analogous to the relationship between a class and an object in software development: the image is the blueprint; the container is the running instance.

Containers are ephemeral by design. If a container stops or crashes, the state inside it is typically lost unless explicitly persisted to external storage. This is intentional - it encourages stateless application design and makes scaling and recovery straightforward.

Isolation in Containers

Containers provide isolation at multiple levels:

Isolation TypeWhat It Provides
Process IsolationProcesses in one container cannot see or affect processes in another container or on the host
Filesystem IsolationEach container has its own filesystem view derived from the image; changes inside one container are not visible to others unless shared volumes are used
Network IsolationContainers can have their own network interfaces and IP addresses, with controlled communication rules
Resource IsolationCPU and memory can be limited per container via cgroups, preventing one container from consuming all host resources

Portability

Because a container image bundles everything the application needs, it runs consistently on any system with a compatible container runtime - a developer's laptop, an on-premise server, a cloud virtual machine, or a Kubernetes cluster. This "build once, run anywhere" property is the core promise of containerization.

Key Benefits Of Containerization

BenefitDescription
ConsistencyThe same image runs identically in development, testing, and production, eliminating environment-related discrepancies
EfficiencyContainers share the host OS kernel, requiring far less overhead than VMs — more workloads per server
SpeedContainers start in seconds, enabling rapid deployment and fast scaling
IsolationApplications are isolated from each other, reducing the risk of interference and limiting the impact of failures
PortabilityImages run on any container-compatible infrastructure, enabling flexibility in deployment targets
ReproducibilityImmutable images with layered, version-controlled builds ensure consistent, auditable deployments

Containerization and SAP Edge Integration Cell

EIC is entirely built on container technology. When SAP delivers an EIC release, it publishes a set of container images to a container registry. Each logical component of EIC - the runtime engine that executes integration flows, the policy enforcement layer, the message service - is packaged as one or more container images.

When you deploy EIC to your Kubernetes cluster using Edge Lifecycle Management (ELM), those images are pulled and started by Kubernetes. The benefits that containerization delivers to any application apply equally to EIC:

  • Consistency: EIC components behave identically regardless of whether your Kubernetes cluster runs on-premise or on Azure, AWS, or GCP
  • Isolation: EIC components are isolated from other applications on the same cluster and from each other
  • Portability: The same EIC container images run on AKS, EKS, GKE, SUSE Rancher RKE2, and Red Hat OpenShift - any supported Kubernetes platform
  • Updatability: When SAP releases an EIC update, ELM pulls new container images and replaces the running containers in a controlled manner, with minimal downtime

Understanding containers is therefore not just theoretical background - it is directly relevant to understanding how EIC is deployed, updated, and operated.

Scenario Check-In - Global Manufacturing AG

Every component of Global Manufacturing AG's Edge Integration Cell deployment - the integration runtime, the API policy engine, the message service - is delivered by SAP as a set of container images. These images are immutable: the exact software that SAP tested during quality assurance is the same software that runs in Global Manufacturing AG's Frankfurt data center. No manual installation, no dependency conflicts, no environment-specific surprises.

SAP publishes the EIC images to a container registry. When Edge Lifecycle Management deploys EIC, it pulls these images and hands them to the container runtime on Global Manufacturing AG's infrastructure, which starts them as running containers - isolated from each other and from other workloads on the same machines.

Because container images are portable, they run identically whether Global Manufacturing AG operates its current SUSE Rancher RKE2 environment or moves to a different supported platform in the future. The technology choice does not change what SAP delivers - only where it runs.

Key Takeaways

Containerization solves environment-dependent software behavior by packaging an application and all its dependencies into an immutable, portable unit - the Container Image. Images are distributed through Container Registries and executed by a Container Runtime, producing Containers: lightweight, isolated, running instances that start in seconds and behave identically on any compatible infrastructure.

SAP delivers every EIC component as container images. When you deploy EIC using Edge Lifecycle Management, those images are pulled and started on your Kubernetes cluster - consistently, whether on AKS, EKS, GKE, RKE2, or OpenShift.

In Lesson 3.2, you will learn how these containers are managed at scale - through Kubernetes, the orchestration platform that underpins every EIC deployment.

Further Resources