Exploring Kubernetes Concepts in EIC

Objective

After completing this lesson, you will be able to describe the runtime components of Edge Integration Cell, explain how they map to Kubernetes workloads, and describe the role of Edge Lifecycle Management in deploying and maintaining EIC.

Introduction

Lessons 3.1 and 3.2 established the technical foundation - containers for packaging, Kubernetes for orchestration. This lesson shifts from architecture to application: how do EIC's specific components map to the Kubernetes objects you just learned? Which workloads run as Deployments, how do they communicate through Services, what storage do they need, and how does Edge Lifecycle Management orchestrate the full deployment lifecycle? The focus is entirely on the customer-managed data plane - what runs inside your cluster and how it is organized.

EIC Runtime Components

EIC Is Not a Single Container

A common misconception is that "deploying EIC" means starting a single container. In reality, EIC is a set of cooperating components, each running as one or more Kubernetes Pods. Understanding this composition is essential for planning capacity, troubleshooting, and understanding what Edge Lifecycle Management (ELM) manages on your behalf.

Core EIC Runtime Components

EIC's runtime is composed of three main components, each running as containerized workloads managed by Kubernetes Deployments:

Worker

The Worker is the core integration runtime of EIC. It is a Camel-based engine - built on Apache Camel, the same integration framework used by SAP Integration Suite's Cloud Integration Runtime. It runs as a Kubernetes Deployment, typically with three Pod replicas in production for load distribution and high availability.

The Worker executes Integration Flows (iFlows) deployed from the SAP Integration Suite Cockpit. When a message arrives from a sender system, the Worker applies the transformation and routing logic defined in the iFlow and forwards the result to the target system. It supports the same adapter types and iFlow steps as the Cloud Integration Runtime - an iFlow designed for Cloud Integration is largely compatible with EIC and will typically run without modification.

For Global Manufacturing AG, the Worker is where the quality inspection data flow between SAP S/4HANA and the QMS actually executes.

Policy Engine

The Policy Engine is based on Envoy, a high-performance, open-source proxy. It enforces authentication, authorization, and traffic management policies - including rate limiting - for API artifacts deployed to EIC. In collaboration with the Edge Local Authentication and Authorization component, it also handles inbound authentication and authorization for integration flows. All enforcement happens locally, without routing calls to the cloud. The Policy Engine also writes Message Processing Log parts.

For Global Manufacturing AG, this means that if the QMS exposes an API that SAP S/4HANA consumes through EIC, the Policy Engine can enforce access controls and rate limits directly within the Frankfurt network - no external dependency required.

Message Service

All EIC components are deployed into a set of Kubernetes namespaces. By default, the primary namespace is edge-icell, which contains the core runtime workloads. Additional namespaces - edge-icell-services, edge-icell-secrets, edge-icell-ela, and istio-gateways - are created automatically during deployment for supporting services, secrets management, and ingress routing. Namespaces can be configured, and multiple EIC instances can be deployed within a single Kubernetes cluster, each using its own distinct set of namespaces.

For Global Manufacturing AG, this is relevant when quality inspection results from SAP S/4HANA must be delivered reliably to the QMS even during temporary system unavailability - the Message Service holds the data until the target system is ready to receive it.

External Services for EIC

Beyond the three core runtime components, a production EIC deployment requires additional infrastructure services:

PostgreSQL or SAP HANA (External Database)

EIC uses a relational database for:

  • Storing runtime metadata and configuration
  • Persisting message store data used by iFlows that store messages before or during processing
  • Maintaining deployment state information
  • Storing Message Processing Logs (MPLs) for monitoring

For production deployments, SAP requires this database to be external to the Kubernetes cluster - either a managed cloud database service (for example, Azure Database for PostgreSQL or Amazon RDS) or a self-managed enterprise database. Running the database inside the cluster is only appropriate for test and development environments, because in-cluster instances create failure coupling between the application and the storage layer.

In Kubernetes terms, the external database is accessed via a Service reference (or direct endpoint). If a cluster-internal database os used (for testing), it runs as a Pod with a PersistentVolumeClaim.

As introduced in Unit 2, Lesson 2.6, provisioning the external database is a prerequisite task for production deployment - handled by the customer's DBA or cloud infrastructure team.

Redis, Valkey or SAP HANA (External Cache)

EIC can use Redis, Valkey, or SAP HANA as an external distributed cache for session management, state management, and API policy enforcement. For production HA deployments, an external Redis, Valkey, or SAP HANA datastore is required. (For Quota or Surge Protection policies in highly scalable workloads, Redis is recommended as the datastore to ensure optimal performance.)

Cloud Connector (Embedded in Edge Lifecycle Management)

The Cloud Connector embedded within Edge Lifecycle Management maintains a secure outbound HTTPS tunnel to SAP Business AI Platform - the connection is always initiated from within the private network, not from the cloud side. Through this tunnel, the Cloud Connector receives deployment commands from the control plane and passes them to the local EIC runtime, while enabling the SAP Integration Suite Cockpit to query operational monitoring data on-demand through the Cloud Connector. It runs as a containerized workload within the edge-icell namespace and requires no inbound firewall ports - SAP's cloud infrastructure never needs to establish inbound connections to your cluster.

This is the communication mechanism introduced in Unit 2, Lesson 2.3.

Note

EIC also supports an external Cloud Connector installation, where the customer operates the Cloud Connector independently. This option is used in environments where the embedded variant is not suitable. This course focuses on the embedded variant, which is the default configuration.

Source: SAP Help Portal — Network and Communication Security for Edge Integration Cell

The EIC Namespace

All EIC components are deployed into a set of Kubernetes namespaces. By default, the primary namespace is edge-icell, which contains the core runtime workloads. Additional namespaces - edge-icell-services, edge-icell-secrets, edge-icell-ela, and istio-gateways - are created automatically during deployment for supporting services, secrets management, and ingress routing. 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.

This has important operational implications:

Multiple instances: Multiple EIC instances can be deployed within a single Kubernetes cluster. Each instance requires its own distinct set of configured namespaces.

Logical isolation: The primary EIC namespace isolates EIC workloads from other applications on the same cluster. Kubernetes RBAC can be used to restrict access to this namespace to authorized personnel.

ELM dependency: The namespace and all resources within it are managed by Edge Lifecycle Management. Manual modifications to resources in this namespace risk conflicting with ELM's desired-state management and should be avoided in production environments.

Source: SAP Community — FAQ on Edge Integration Cell

Kubernetes Objects in EIC

Lesson 3.2 covered Pod, Deployment, Service, and Namespace. EIC uses additional Kubernetes objects that become relevant in the context of a concrete deployment.

ConfigMap

A ConfigMap stores non-sensitive configuration data as key-value pairs. Applications can consume ConfigMaps as environment variables or mounted configuration files. Kubernetes uses ConfigMaps to pass configuration to EIC components without hard-coding values into container images - for example, runtime parameters, endpoint addresses, and behavioral flags.

Secret

A Secret is similar to a ConfigMap but designed for sensitive data such as passwords, API keys, and certificates. Secrets are stored in a protected manner (with additional encryption at rest when configured). EIC uses Secrets to manage credentials for connecting to SAP Business AI Platform and for accessing external services such as the database and cache.

PersistentVolume and PersistentVolumeClaim

Containers are ephemeral - data written inside a container's filesystem is lost when the container stops. For data that must survive container restarts, Kubernetes provides:

  • PersistentVolume (PV): A piece of storage provisioned in the cluster - either manually or dynamically by a StorageClass - that exists independently of any Pod
  • PersistentVolumeClaim (PVC): A request for storage from a Pod. The PVC binds to an available PV of the requested size and access mode

Relevance to EIC: EIC components that require local persistent storage - for example, runtime data and monitoring/logging components in test environments - use PVCs. SAP requires that your Kubernetes cluster supports dynamic provisioning of PersistentVolumes (RWO: ReadWriteOnce for single-node access; RWX: ReadWriteMany for multi-node access). This is handled via a StorageClass.

Source: SAP Help Portal - Operating Edge Integration Cell

LoadBalancer Service

For EIC to receive integration messages from on-premise systems, its HTTPS endpoint must be reachable from within the private network. EIC exposes this endpoint through a Kubernetes service, supporting three service types: LoadBalancer, NodePort, and ClusterIP. The LoadBalancer option provisions an external load balancer (on cloud Kubernetes platforms such as AKS, EKS, or GKE) or a virtual IP (on on-premise clusters) and routes incoming traffic to the available Worker Pods, assigning a stable IP address or DNS hostname to EIC's integration endpoint.

Ingress

An Ingress resource (managed by an Ingress Controller such as Nginx or the Istio Ingress Gateway used by EIC) provides hostname- and path-based routing for incoming traffic. EIC uses an Ingress (via Istio) to route incoming requests to the appropriate internal service based on the request path or hostname - enabling multiple integration endpoints to share a single external IP address.

Note

EIC deploys and manages its own Istio installation within the configured EIC namespace as part of the standard deployment. If your cluster already has Istio installed, a Restricted Cluster Installation variant is required (see SAP Note 3618713).

Edge Lifecycle Management

Edge Lifecycle Management (ELM) is the SAP service responsible for the full lifecycle of EIC - from initial deployment through ongoing updates, configuration changes, and health monitoring. ELM runs as part of SAP Integration Suite on SAP Business AI Platform and manages your private EIC deployment through the Cloud Connector's secure channel.

As introduced in Unit 2, Lesson 2.6, ELM manages:

  • Initial onboarding: Registering your Kubernetes cluster as an Edge Node and bootstrapping the EIC installation
  • Software delivery: Pulling EIC container images from SAP's container registry and deploying them to the cluster
  • Lifecycle operations: Orchestrating updates to new EIC versions, applying rolling upgrades to minimize or eliminate downtime
  • Configuration management: Propagating configuration changes from the SAP Integration Suite Cockpit to the running EIC deployment
  • Health visibility: Providing EIC instance health status visible in the SAP Integration Suite Cockpit

A critical step before deploying EIC is the ELM Prerequisite Validation. ELM performs automated checks - connectivity to SAP Business AI Platform endpoints, Kubernetes API server access, storage class availability, and load balancer provisioning - before attempting installation, helping identify and resolve configuration issues proactively.

Source: SAP Help Portal — ELM Prerequisite Validation Procedures

EIC Deployment and Sizing

Once ELM has deployed EIC to the Kubernetes cluster, a key decision determines how resilient the deployment is: the choice between a Non-HA and an HA (High Availability) configuration:

ConfigurationUse CaseWorker ReplicasResource Profile
Non-HADevelopment, proof of concept, testing1 Pod replica~10 CPU cores, ~32 GiB RAM (total cluster), ~101 GiB storage
HAProduction2 Pod replicas across multiple nodes~20 CPU cores, ~64 GiB RAM (total cluster), ~204 GiB storage

In HA mode, key EIC components - particularly the Worker - run as multiple Pod replicas distributed across multiple worker nodes. If one node fails, the remaining Worker replicas continue processing messages without interruption. This is the Kubernetes Deployment model in practice: the desired state specifies two Worker replicas, and Kubernetes maintains that regardless of individual node failures.

These are minimum baseline values for total cluster resource requirements (sum of all EIC component requests). Additional capacity is needed for the Kubernetes Control Plane overhead, operating system processes, monitoring and logging components, and growth in message volume. Consult SAP's official sizing guidance (SAP Note 3705131) before provisioning.

Source: SAP Help Portal — Operating Edge Integration Cell

Scenario Check-In: Global Manufacturing AG

GlobalManufacturing AG has deployed EIC in HA mode on their RKE2 cluster. The Worker runs as three Pod replicas distributed across three nodes; the Policy Engine and Message Service each run with two replicas. All components reside in the edge-icell namespace set. A LoadBalancer Service exposes EIC's HTTPS integration endpoint to S/4HANA and the QMS within the private Frankfurt network - no traffic leaves the building. The external PostgreSQL or SAP HANA database and the Redis or Valkey cache are provisioned as external production-grade services outside the cluster. ELM monitors the deployment and handles all updates when SAP releases new EIC versions, so the integration team interacts only with the SAP Integration Suite Cockpit.

Key Takeaways

EIC consists of three core runtime components - Worker, Policy Engine, and Message Service - deployed as Kubernetes workloads in the edge-icell namespace. They are supported by an external database, an optional external cache, and the Cloud Connector embedded in ELM, which maintains a secure outbound tunnel to SAP Business AI Platform. ELM manages the full deployment lifecycle. EIC can run in Non-HA (development) or HA (production) configuration.

In Lesson 3.4, you will follow a single integration message through the EIC cluster and see these components in action.