When a developer builds an integration scenario in SAP Integration Suite, they work with specific technical objects. These objects represent the vocabulary of Cloud Integration. Since Edge Integration Cell uses the same design-time model and the same types of integration artifacts as Cloud Integration, the concepts introduced in this lesson apply in both environments. You design your integration content once and can deploy it to either runtime.
Important distinction: While the design-time concepts and integration artifacts are the same, the underlying runtime environments differ. EIC runs on a separate, Kubernetes-based runtime in the customer's private infrastructure - distinct from the SAP-managed Cloud Integration Runtime that runs on SAP Business AI Platform. As a result, not all features available in Cloud Integration are supported in EIC. For a detailed comparison, see: Supported Features and Limitations of Edge Integration Cell.
Think of these concepts as the building blocks of an integration project. Just as a software developer writes code organized in functions and modules, an integration developer models logic in Integration Flows using adapters, mappings, and routing rules - all organized into Integration Packages.
The following sections introduce the key concepts. Note that this lesson covers the most important artifacts and vocabulary. SAP Cloud Integration provides additional step types, configuration options, and patterns beyond what is covered here - the concepts below represent the foundational vocabulary needed for this course.
Integration Package
An Integration Package is the organizational container for integration content in SAP Integration Suite. It groups related artifacts - such as Integration Flows, Value Mappings, APIs, and Script Collections - and enables joint management, versioning, and deployment. Customers create their own packages for their specific integration scenarios.
Analogy: An Integration Package is like a project folder on your computer. The folder itself does not process anything - it organizes the files inside it. You can version it, share it, and deploy all its contents together.
To make this concrete: At Global Manufacturing AG, the S/4HANA-to-QMS integration would be organized as a dedicated Integration Package - for example, "Quality Integration - S/4HANA to QMS", containing all related Integration Flows and configuration artifacts.
Protocol and Adapter
Understanding Protocols: A protocol is an agreed set of rules that governs how two systems communicate. It defines how data is transmitted, structured, and acknowledged. Different protocols are used depending on the systems and use case:
- HTTP/HTTPS - standard protocol for web-based communication and REST APIs
- SFTP - Secure File Transfer Protocol, for file-based data exchange
- SOAP - Simple Object Access Protocol, for structured XML-based web services
- RFC (Remote Function Call) - SAP's proprietary protocol for calling ABAP function modules in SAP systems
- OData - Open Data Protocol, for querying and manipulating data via RESTful APIs
Understanding Adapters: An adapter connects SAP Integration Suite with a specific system or protocol. It abstracts the technical communication details so the developer does not need to implement low-level protocol logic manually. The developer configures the adapter with connection parameters; the adapter handles the technical communication.
Analogy: An adapter is like a universal plug converter. You have a device (your integration flow) and a socket (the external system). The adapter is the converter that makes them compatible - regardless of whether the socket uses HTTP, SFTP, or RFC.
SAP provides a comprehensive library of adapters for SAP and non-SAP systems. In the EIC context, some adapters are only available in the EIC runtime - because they are designed specifically for communication within a private network (for example, the RFC adapter for direct on-premise communication, without requiring SAP Cloud Connector). Unit 2 covers this in detail.
Message
A message is the fundamental data unit that Cloud Integration processes. When an integration scenario runs, it receives an incoming message from a source system, processes it according to the Integration Flow logic, and sends a resulting message to a target system.
A message in Cloud Integration consists of three parts:
| Part | Description |
| Body (Payload) | The actual business data - for example, an XML document with quality inspection results. This is what the target system receives. |
| Header | Routing metadata: timestamps, message IDs, sender and receiver information. |
| Exchange Properties | Internal processing variables set within the Integration Flow - used during processing, never sent to the target system. |
Analogy: A message is like a courier package. The body is the item inside (the actual goods). The header is the shipping label (address, tracking number, sender). The exchange properties are sticky notes the courier attaches internally for special handling - visible only during processing, never delivered to the recipient.
API and Event
API (Application Programming Interface): An API is a defined access point to the functions or data of a system. In integration architectures, APIs connect applications in a controlled and standardized way - the calling system does not need to understand the internal implementation of the target system.
Example: SAP S/4HANA exposes an OData API for material master data. The QMS can call this API to retrieve material specifications - without any direct database access to S/4HANA.
In SAP Integration Suite, API Management governs how APIs are exposed, secured, and consumed. With Edge Integration Cell, API proxies can also run locally within private infrastructure - a capability covered in Unit 2.
Event An event describes an occurrence in a system to which other systems can react - for example, "quality inspection completed" or "production order released." Events enable decoupling: the sender publishes an event without knowing who will react to it or when.
This contrasts with an API call, where the caller explicitly addresses a specific receiver and waits for a response. Events are asynchronous by nature - fire and forget.
In SAP Integration Suite, Event Mesh and the Advanced Event Mesh capability act as the event broker for event-driven communication.
Mapping
Mapping refers to the transformation of data from a source structure (the format sent by the source system) into a target structure (the format expected by the target system).
Most real- world integration scenarios require mapping because systems rarely use identical data structures. For example, SAP S/4HANA might represent a quality lot as a structured BAPI result, while the QMS expects a specific XML schema. The mapping step in the Integration Flow transforms one into the other.
Cloud Integration provides a visual mapping editor where developers can graphically define source-to-target field relationships and apply transformation rules (e.g., value conversions, concatenations, conditional logic).
Routing
Routing determines where a message is sent based on conditions evaluated at runtime. In an Integration Flow, routing enables you to direct messages to different processing branches or receiver systems depending on message content, headers, or properties.
Cloud Integration supports several routing patterns:
- Content- Based Router - evaluates the message content (e.g., an XML field value) to decide which processing branch to follow. For example: if the material type is "raw material," route to the QMS; if it is "finished goods," route to the logistics platform.
- Multicast - sends the same message to multiple receivers simultaneously. For example: a production completion event is sent to both the QMS and the analytics platform.
- Recipient List - dynamically determines the list of receivers at runtime, based on message content or lookup tables.
Routing is configured within the Integration Flow using graphical modeling - no custom code is required.
Content Modifier and Processing Steps
Beyond the core concepts above, an Integration Flow typically includes additional processing steps that manipulate messages during execution. The most common is the Content Modifier - a step that allows developers to set, change, or remove message headers, exchange properties, and body content without writing code.
Other common processing steps include:
| Step Type | Purpose |
| Content Modifier | Set or modify headers, properties, and message body content. |
| Groovy Script / JavaScript | Execute custom logic when built-in steps are not sufficient. |
| Filter | Extract a subset of the message content (e.g., specific XML nodes). |
| Splitter | Divide a single message into multiple individual messages for parallel processing. |
| Aggregator | Combine multiple messages into a single message based on a correlation condition. |
| Converter | Convert between data formats (e.g., XML to JSON, CSV to XML). |
| Exception Subprocess | Define error-handling logic that executes when a processing error occurs. |
| Persist / Log | Store message content or metadata for monitoring and troubleshooting purposes. |
These steps are configured within the graphical Integration Flow editor - most require no code. The combination of adapters, routing, mapping, and processing steps gives the developer a comprehensive toolkit for building integration logic.
Integration Flow
An Integration Flow (iFlow) models the integration logic for one integration scenario in Cloud Integration. It defines the sequence of processing steps from message reception, through transformation, routing, and enrichment, to delivery to the target system. All the concepts introduced above - adapters, messages, mappings, routing, content modifiers - come together inside an Integration Flow.
An Integration Flow is created in the Design Time of SAP Integration Suite (the web-based Cockpit) and then deployed to a runtime - either the Cloud Integration Runtime or an Edge Integration Cell instance. The runtime is where the iFlow actually executes and processes live messages.
Note
A single Integration Flow typically models one integration scenario (e.g., "send inspection request from S/4HANA to QMS"). For complex end- to- end business processes that span multiple systems and multiple steps, several Integration Flows may be combined - for example, using the ProcessDirect adapter to chain one iFlow into another.
This distinction between Design Time and Runtime is the architectural principle that makes Edge Integration Cell possible - and it is the topic of Lesson 4.
Returning to our example: At Global Manufacturing AG, the S/4HANA-to-QMS integration would be implemented as Integration Flows. One iFlow sends a usage decision request from S/4HANA to the QMS (RFC → XML/HTTP), and another receives the inspection result back (HTTP → RFC). Both iFlows would be deployed to the Edge Integration Cell instance in the private data center - not to the cloud runtime. The reason for this deployment decision is explained in Lesson 4.
SAP Business Accelerator Hub
SAP and partners provide a large library of pre-built Integration Packages for common integration scenarios. These are published on the SAP Business Accelerator Hub - a central catalog where you can discover, explore, and test integration content, APIs, events, and other digital assets.
When starting a new integration project, checking the Hub first is a recommended practice: a pre-built package for your scenario may already exist. You can copy it into your Design workspace and adapt it to your requirements - instead of building everything from scratch.