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.
Exploring Kubernetes Concepts in EIC
Objective
Introduction
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
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.
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.
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
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:
| Configuration | Use Case | Worker Replicas | Resource Profile |
| Non-HA | Development, proof of concept, testing | 1 Pod replica | ~10 CPU cores, ~32 GiB RAM (total cluster), ~101 GiB storage |
| HA | Production | 2 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.
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.
Further Resources
SAP Help – Technical Landscape for Edge Integration Cell
SAP Help – Operating Edge Integration Cell
https://help.sap.com/docs/integration-suite/sap-integration-suite/operating-edge-integration-cell
SAP Community – FAQ on Edge Integration Cell
SAP Help – Network and Communication Security
https://help.sap.com/docs/integration-suite/sap-integration-suite/network-and-communication-security