Steampunk vs. Embedded Steampunk: ABAP Cloud Architekturen im Vergleich

kategorie

ABAP Cloud

Veröffentlicht

Feb 14, 2026

autor

Steampunk und Embedded Steampunk sind zwei Architekturen für ABAP Cloud-Entwicklung. Beide nutzen die gleiche ABAP Cloud-Programmiersprache, unterscheiden sich aber grundlegend in Deployment, Datenhaltung und Anwendungsfällen. Dieser Artikel erklärt die Unterschiede und hilft bei der Auswahl des richtigen Modells.

Begriffsklärung

SAP verwendet verschiedene Bezeichnungen für seine ABAP Cloud-Umgebungen:

Begriff	Offizielle Bezeichnung	Umgebung
Steampunk	SAP BTP ABAP Environment	Eigenständige BTP-Instanz
Embedded Steampunk	S/4HANA Cloud ABAP Environment	Teil von S/4HANA Cloud

Der Name “Steampunk” entstand als interner SAP-Codename und hat sich in der Community etabliert.

Architekturen im Überblick

Steampunk (BTP ABAP Environment)

┌─────────────────────────────────────────────────────────┐
│                  SAP Business Technology Platform        │
├─────────────────────────────────────────────────────────┤
│  ┌────────────────────────────────────────────────────┐ │
│  │           BTP ABAP Environment                     │ │
│  │  ┌────────────────┬───────────────────────────┐   │ │
│  │  │  ABAP Runtime  │    SAP HANA Database      │   │ │
│  │  │                │    (dediziert)            │   │ │
│  │  │  - RAP         │                           │   │ │
│  │  │  - CDS         │    ┌─────────────────┐    │   │ │
│  │  │  - ABAP Cloud  │    │  Eigene Daten   │    │   │ │
│  │  │                │    │  (keine S/4)    │    │   │ │
│  │  └────────────────┴────┴─────────────────┴────┘   │ │
│  └────────────────────────────────────────────────────┘ │
│                           │                              │
│                    OData / REST APIs                     │
│                           │                              │
│  ┌────────────────────────▼────────────────────────────┐│
│  │              S/4HANA (optional)                     ││
│  │         (Integration via APIs)                      ││
│  └─────────────────────────────────────────────────────┘│
└─────────────────────────────────────────────────────────┘

Kernmerkmale:

Vollständig eigenständige ABAP-Umgebung
Eigene HANA-Datenbank ohne S/4HANA-Daten
Integration mit S/4HANA nur über APIs (Side-by-Side)
Unabhängige Release-Zyklen
Multi-Cloud-fähig (AWS, Azure, GCP)

Embedded Steampunk (S/4HANA Cloud ABAP Environment)

┌─────────────────────────────────────────────────────────┐
│                   S/4HANA Cloud System                   │
├─────────────────────────────────────────────────────────┤
│  ┌────────────────────────────────────────────────────┐ │
│  │               Standard S/4HANA                      │ │
│  │  ┌──────────────────────────────────────────────┐  │ │
│  │  │            SAP Standard Code                 │  │ │
│  │  │  (Financials, Logistics, etc.)               │  │ │
│  │  └──────────────────────────────────────────────┘  │ │
│  │                        │                            │ │
│  │  ┌────────────────────▼─────────────────────────┐  │ │
│  │  │    ABAP Cloud Environment (Embedded)         │  │ │
│  │  │                                              │  │ │
│  │  │  ┌──────────────────────────────────────┐   │  │ │
│  │  │  │  Custom Code (ABAP Cloud)            │   │  │ │
│  │  │  │  - Released APIs only                │   │  │ │
│  │  │  │  - RAP Extensions                    │   │  │ │
│  │  │  │  - BAdI Implementations              │   │  │ │
│  │  │  └──────────────────────────────────────┘   │  │ │
│  │  └──────────────────────────────────────────────┘  │ │
│  │                        │                            │ │
│  │  ┌────────────────────▼─────────────────────────┐  │ │
│  │  │         Gemeinsame HANA Datenbank            │  │ │
│  │  │   (S/4HANA Daten + Custom Tabellen)          │  │ │
│  │  └──────────────────────────────────────────────┘  │ │
│  └────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘

Kernmerkmale:

Teil des S/4HANA Cloud-Systems
Direkter Zugriff auf S/4HANA-Daten über Released APIs
On-Stack-Erweiterung des Standards
SAP-verwaltete Updates und Releases
Keine separate Lizenzierung erforderlich

Detaillierter Vergleich

Architektur und Deployment

Aspekt	Steampunk	Embedded Steampunk
Deployment	Eigenständige BTP-Instanz	Teil von S/4HANA Cloud
Datenbank	Eigene HANA-Instanz	Gemeinsame S/4HANA DB
Isolierung	Vollständig isoliert	Im S/4HANA-Stack
Skalierung	Unabhängig skalierbar	Mit S/4HANA skaliert
Multi-Cloud	AWS, Azure, GCP, SAP DC	SAP-Rechenzentren

Verfügbare APIs und Released Objects

Beide Umgebungen nutzen das ABAP Cloud-Modell, aber mit unterschiedlichem Scope:

CLASS zcl_api_comparison DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun.
ENDCLASS.

CLASS zcl_api_comparison IMPLEMENTATION.
  METHOD if_oo_adt_classrun~main.
    " ═══════════════════════════════════════════════════════
    " APIs in BEIDEN Umgebungen verfügbar:
    " ═══════════════════════════════════════════════════════

    " ABAP Basis APIs
    DATA(lo_random) = cl_abap_random_int=>create(
      seed = cl_abap_random=>seed( )
      min  = 1
      max  = 100
    ).
    out->write( |Random: { lo_random->get_next( ) }| ).

    " XCO Library
    DATA(lo_table) = xco_cp_abap_dictionary=>database_table( 'SFLIGHT' ).
    IF lo_table->exists( ).
      out->write( 'SFLIGHT existiert' ).
    ENDIF.

    " HTTP Client
    DATA(lo_client) = cl_web_http_client_manager=>create_by_http_destination(
      cl_http_destination_provider=>create_by_url( 'https://api.example.com' )
    ).

    " ═══════════════════════════════════════════════════════
    " APIs NUR in Embedded Steampunk (S/4HANA):
    " ═══════════════════════════════════════════════════════

    " S/4HANA Business Objects (nur in S/4HANA Cloud)
    " SELECT * FROM I_SalesOrder WHERE ...
    " SELECT * FROM I_BusinessPartner WHERE ...
    " SELECT * FROM I_Product WHERE ...

    " Diese CDS Views sind in BTP ABAP Environment
    " NICHT verfügbar, da keine S/4HANA-Daten vorhanden!

    out->write( 'API-Vergleich abgeschlossen' ).
  ENDMETHOD.
ENDCLASS.

Released Objects Vergleich

Kategorie	Steampunk (BTP)	Embedded Steampunk
ABAP Basis	✅ Vollständig	✅ Vollständig
XCO Library	✅ Vollständig	✅ Vollständig
RAP Runtime	✅ Vollständig	✅ Vollständig
CDS Infrastruktur	✅ Vollständig	✅ Vollständig
S/4HANA Business Objects	❌ Nicht verfügbar	✅ Released APIs
I_SalesOrder, I_Customer, etc.	❌	✅
S/4HANA BAdIs	❌	✅ Released BAdIs
S/4HANA Behavior Extensions	❌	✅

Transportwesen und Lifecycle

┌─────────────────────────────────────────────────────────┐
│              Steampunk (BTP ABAP Environment)            │
├─────────────────────────────────────────────────────────┤
│                                                          │
│  Git Repository (abapGit / gCTS)                        │
│         │                                                │
│         ▼                                                │
│  ┌─────────┐    ┌─────────┐    ┌─────────┐              │
│  │   DEV   │ ─► │   QAS   │ ─► │   PRD   │              │
│  │(Branch 1│    │(Branch 2│    │(Main)   │              │
│  └─────────┘    └─────────┘    └─────────┘              │
│                                                          │
│  ► Selbstverwaltete Landschaft                          │
│  ► Flexible Branch-Strategie                            │
│  ► CI/CD-Integration möglich                            │
│  ► Eigene Release-Zyklen                                │
│                                                          │
└─────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────┐
│        Embedded Steampunk (S/4HANA Cloud)                │
├─────────────────────────────────────────────────────────┤
│                                                          │
│  Software Component (ATO)                               │
│         │                                                │
│         ▼                                                │
│  ┌─────────┐    ┌─────────┐    ┌─────────┐              │
│  │   DEV   │ ─► │   TST   │ ─► │   PRD   │              │
│  │ (fest)  │    │ (fest)  │    │ (fest)  │              │
│  └─────────┘    └─────────┘    └─────────┘              │
│                                                          │
│  ► SAP-verwaltete Landschaft                            │
│  ► Feste 3-System-Landschaft                            │
│  ► Quartalsweise SAP-Updates                            │
│  ► Transport über ATO (Adaptation Transport Organizer)  │
│                                                          │
└─────────────────────────────────────────────────────────┘

Anwendungsfälle

Wann Steampunk (BTP ABAP Environment)?

Ideale Szenarien:

Neue Cloud-Native Anwendungen
- Eigenständige Geschäftsanwendungen
- Microservices mit ABAP-Backend
- APIs für externe Partner
Multi-Tenant SaaS-Lösungen
- Eigene Software-Produkte
- Kundenübergreifende Plattformen
S/4HANA-unabhängige Entwicklung
- Kein S/4HANA-System vorhanden
- Unabhängige Release-Zyklen erforderlich
Integration Hub
- Zentrale Integrationsplattform
- API-Orchestrierung

CLASS zcl_btp_use_case DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    " Beispiel: Eigenständige SaaS-Anwendung auf BTP
    METHODS process_external_order
      IMPORTING
        iv_order_json TYPE string
      RETURNING
        VALUE(rv_result) TYPE string.
ENDCLASS.

CLASS zcl_btp_use_case IMPLEMENTATION.
  METHOD process_external_order.
    " Eigene Geschäftslogik - unabhängig von S/4HANA
    TRY.
        " JSON parsen
        DATA(lo_json) = /ui2/cl_json=>deserialize(
          json = iv_order_json
          jsonx = '' ).

        " Eigene Tabellen verwenden (nicht S/4HANA)
        INSERT INTO zorders VALUES @ls_order.

        " Integration mit beliebigen Backends
        DATA(lo_client) = cl_web_http_client_manager=>create_by_http_destination(
          cl_http_destination_provider=>create_by_url(
            'https://erp-backend.example.com/api/orders' )
        ).

        " Verarbeitung...
        rv_result = 'SUCCESS'.

      CATCH cx_root INTO DATA(lo_error).
        rv_result = lo_error->get_text( ).
    ENDTRY.
  ENDMETHOD.
ENDCLASS.

Wann Embedded Steampunk (S/4HANA Cloud)?

Ideale Szenarien:

S/4HANA-Erweiterungen
- Custom Fields und Logik
- Prozessanpassungen
- BAdI-Implementierungen
Integration mit Standard
- Eigene Apps mit S/4HANA-Daten
- Erweiterung von Standardprozessen
- Custom Reports auf S/4HANA-Daten
Side-by-Side ist keine Option
- Latenz-kritische Prozesse
- Hohe Datenvolumen
- Enge Koppelung erforderlich
Clean Core-Strategie
- Erweiterungen ohne Modifikation
- Upgrade-sichere Anpassungen

CLASS zcl_embedded_use_case DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    " Beispiel: S/4HANA-Erweiterung
    METHODS get_customer_with_orders
      IMPORTING
        iv_customer TYPE kunnr
      RETURNING
        VALUE(rs_result) TYPE zts_customer_orders.
ENDCLASS.

CLASS zcl_embedded_use_case IMPLEMENTATION.
  METHOD get_customer_with_orders.
    " Direkter Zugriff auf S/4HANA-Daten über Released APIs
    SELECT SINGLE
      Customer,
      CustomerName,
      CustomerFullName,
      CustomerClassification
    FROM I_Customer
    WHERE Customer = @iv_customer
    INTO @rs_result-customer_data.

    " Aufträge des Kunden
    SELECT
      SalesOrder,
      SalesOrderType,
      SalesOrganization,
      NetAmount,
      TransactionCurrency
    FROM I_SalesOrder
    WHERE SoldToParty = @iv_customer
      AND OverallSDProcessStatus <> 'C'
    INTO TABLE @rs_result-open_orders.

    " Eigene Custom-Tabellen kombinieren
    SELECT
      inquiry_id,
      subject,
      status,
      priority
    FROM zinquiry
    WHERE customer = @iv_customer
    INTO TABLE @rs_result-custom_inquiries.
  ENDMETHOD.
ENDCLASS.

Entscheidungsmatrix

Schnellentscheidung nach Kriterien

Kriterium	Steampunk	Embedded Steampunk
S/4HANA-Daten direkt benötigt		✅
Eigenständige Anwendung	✅
Multi-Cloud erforderlich	✅
Standard erweitern (BAdIs)		✅
Unabhängige Releases	✅
Clean Core beibehalten		✅
SaaS-Produkt entwickeln	✅
Bereits S/4HANA Cloud Lizenz		✅

Entscheidungsbaum

                    ┌─────────────────────────┐
                    │  Benötigst du direkten  │
                    │  Zugriff auf S/4HANA-   │
                    │  Geschäftsdaten?        │
                    └───────────┬─────────────┘
                                │
                    ┌───────────┴───────────┐
                    │                       │
                   JA                      NEIN
                    │                       │
        ┌───────────▼───────────┐  ┌───────▼────────────┐
        │  Ist Performance/     │  │  Entwickelst du    │
        │  Latenz kritisch?     │  │  ein eigenes       │
        │                       │  │  Produkt?          │
        └───────────┬───────────┘  └───────┬────────────┘
                    │                       │
            ┌───────┴───────┐       ┌───────┴───────┐
            │               │       │               │
           JA             NEIN     JA             NEIN
            │               │       │               │
            ▼               │       ▼               ▼
    ┌───────────────┐       │ ┌───────────┐ ┌──────────────┐
    │   Embedded    │       │ │ Steampunk │ │  Beide       │
    │   Steampunk   │       │ │   (BTP)   │ │  möglich     │
    └───────────────┘       │ └───────────┘ │              │
                            │               │  Faktoren:   │
                            │               │  - Lizenz    │
                            │               │  - Skills    │
                            │               │  - Strategie │
                            ▼               └──────────────┘
                    ┌───────────────┐
                    │  Side-by-Side │
                    │  Integration  │
                    │  mit BTP      │
                    │  Steampunk    │
                    └───────────────┘

Hybride Szenarien

In der Praxis kombinieren viele Unternehmen beide Ansätze:

Architektur-Beispiel: Enterprise Setup

┌─────────────────────────────────────────────────────────────┐
│                     Unternehmensarchitektur                  │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  ┌────────────────────┐       ┌────────────────────────┐    │
│  │   S/4HANA Cloud    │       │        BTP             │    │
│  │ ┌────────────────┐ │       │ ┌────────────────────┐ │    │
│  │ │Embedded        │ │       │ │  Steampunk         │ │    │
│  │ │Steampunk       │ │◄─────►│ │  (BTP ABAP Env)    │ │    │
│  │ │                │ │  API  │ │                    │ │    │
│  │ │ - Extensions   │ │       │ │ - Integration Hub  │ │    │
│  │ │ - Custom Fields│ │       │ │ - Partner Portal   │ │    │
│  │ │ - BAdIs        │ │       │ │ - Analytics        │ │    │
│  │ └────────────────┘ │       │ └────────────────────┘ │    │
│  └────────────────────┘       └────────────────────────┘    │
│           │                              │                   │
│           │                              │                   │
│           ▼                              ▼                   │
│  ┌─────────────────────────────────────────────────────┐    │
│  │              Fiori Launchpad / Work Zone            │    │
│  │         (Einheitliche Benutzeroberfläche)           │    │
│  └─────────────────────────────────────────────────────┘    │
│                                                              │
└─────────────────────────────────────────────────────────────┘

Kommunikation zwischen den Umgebungen

CLASS zcl_steampunk_integration DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    " BTP Steampunk: Daten von S/4HANA abrufen
    METHODS fetch_s4_data
      IMPORTING
        iv_customer TYPE string
      RETURNING
        VALUE(rs_data) TYPE zts_customer_data.
ENDCLASS.

CLASS zcl_steampunk_integration IMPLEMENTATION.
  METHOD fetch_s4_data.
    " In BTP Steampunk: API-Aufruf nach S/4HANA Cloud
    TRY.
        " Communication Arrangement verwenden
        DATA(lo_destination) = cl_http_destination_provider=>create_by_comm_arrangement(
          comm_scenario  = 'Z_S4_CUSTOMER_API'
          service_id     = 'Z_CUSTOMER_ODATA'
        ).

        DATA(lo_client) = cl_web_http_client_manager=>create_by_http_destination(
          lo_destination ).

        DATA(lo_request) = lo_client->get_http_request( ).
        lo_request->set_uri_path( |/sap/opu/odata/sap/API_BUSINESS_PARTNER/A_Customer('{ iv_customer }')| ).

        DATA(lo_response) = lo_client->execute( if_web_http_client=>get ).
        DATA(lv_json) = lo_response->get_text( ).

        " JSON verarbeiten
        /ui2/cl_json=>deserialize(
          EXPORTING json = lv_json
          CHANGING data = rs_data
        ).

      CATCH cx_http_dest_provider_error
            cx_web_http_client_error INTO DATA(lo_error).
        " Fehlerbehandlung
    ENDTRY.
  ENDMETHOD.
ENDCLASS.

Migration zwischen Umgebungen

Von Steampunk zu Embedded Steampunk

Wenn eine BTP-Anwendung später in S/4HANA integriert werden soll:

1. Code-Analyse
   └─► Welche APIs werden verwendet?
   └─► Gibt es Abhängigkeiten zu BTP-spezifischen Services?

2. Datenmodell prüfen
   └─► Können Tabellen nach S/4HANA migriert werden?
   └─► Gibt es Konflikte mit Standard-Objekten?

3. Transport einrichten
   └─► gCTS-Repository auf S/4HANA einrichten
   └─► Code klonen

4. Anpassungen
   └─► API-Aufrufe auf S/4HANA Released APIs umstellen
   └─► Integration-Logik vereinfachen (direkter DB-Zugriff)

5. Test & Go-Live
   └─► Vollständige Regressionstests
   └─► Schrittweise Migration

Von Embedded Steampunk zu Steampunk

Wenn eine S/4HANA-Erweiterung eigenständig werden soll:

1. Abhängigkeiten identifizieren
   └─► Welche S/4HANA CDS Views werden verwendet?
   └─► Welche BAdIs sind implementiert?

2. API-Schicht erstellen
   └─► OData Services für S/4HANA-Datenzugriff
   └─► Integration über Destinations

3. Daten externalisieren
   └─► Eigene Tabellen anlegen
   └─► Datenreplikation einrichten (optional)

4. Code migrieren
   └─► gCTS/abapGit nutzen
   └─► Direkte DB-Zugriffe durch API-Aufrufe ersetzen

5. Kommunikation einrichten
   └─► Communication Arrangements
   └─► Destination Configuration

Kosten und Lizenzierung

Aspekt	Steampunk	Embedded Steampunk
Grundlizenz	Separate BTP-Lizenz	In S/4HANA Cloud enthalten
Abrechnung	ABAP Compute Units	Teil der S/4-Lizenz
Skalierung	Pay-as-you-go möglich	Feste Kapazität
Entwicklungskosten	Eigene Infrastruktur	Gemeinsam mit S/4

TCO-Überlegungen

Steampunk (BTP ABAP Environment):
├── + Flexible Skalierung
├── + Unabhängige Entwicklung
├── - Zusätzliche Lizenzkosten
├── - Eigene Administration
└── - Integrationsaufwand für S/4-Daten

Embedded Steampunk (S/4HANA Cloud):
├── + Keine zusätzlichen Kosten
├── + Direkter Datenzugriff
├── + SAP-verwaltete Infrastruktur
├── - Feste Update-Zyklen
└── - Weniger Flexibilität

Best Practices

Entscheidungskriterien dokumentieren

" Dokumentation der Architekturentscheidung
" in ABAP Doc Format

"! @title Architekturentscheidung: Steampunk vs. Embedded
"!
"! Entscheidung: Embedded Steampunk
"!
"! Gründe:
"! - Direkter Zugriff auf Kundenauftragsdaten erforderlich
"! - Performance-kritische Validierungen
"! - Keine separate Infrastruktur gewünscht
"! - S/4HANA Cloud-Lizenz bereits vorhanden
"!
"! Alternativen geprüft:
"! - BTP Steampunk: Höhere Integrationskosten
"! - Key User Extensibility: Nicht ausreichend flexibel
"!
"! Risiken:
"! - Abhängigkeit von SAP-Update-Zyklen
"! - Released APIs müssen ausreichen

API-Verfügbarkeit validieren

CLASS zcl_api_validator DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    INTERFACES if_oo_adt_classrun.
ENDCLASS.

CLASS zcl_api_validator IMPLEMENTATION.
  METHOD if_oo_adt_classrun~main.
    " Prüfe, ob benötigte APIs in der Zielumgebung verfügbar sind
    DATA: lt_required_apis TYPE TABLE OF string,
          lt_missing_apis  TYPE TABLE OF string.

    " Liste der benötigten APIs
    lt_required_apis = VALUE #(
      ( 'I_Customer' )
      ( 'I_SalesOrder' )
      ( 'I_Product' )
      ( 'CL_ABAP_RANDOM' )
      ( 'CL_WEB_HTTP_CLIENT_MANAGER' )
    ).

    " Verfügbarkeit prüfen
    LOOP AT lt_required_apis INTO DATA(lv_api).
      " CDS Views prüfen
      IF lv_api CP 'I_*'.
        DATA(lo_view) = xco_cp_cds=>view( CONV #( lv_api ) ).
        IF NOT lo_view->exists( ).
          APPEND lv_api TO lt_missing_apis.
        ENDIF.
      ELSE.
        " Klassen prüfen
        DATA(lo_class) = xco_cp_abap_repository=>object->clas->for(
          CONV #( lv_api ) ).
        IF NOT lo_class->exists( ).
          APPEND lv_api TO lt_missing_apis.
        ENDIF.
      ENDIF.
    ENDLOOP.

    " Ergebnis ausgeben
    IF lt_missing_apis IS INITIAL.
      out->write( '✅ Alle benötigten APIs sind verfügbar' ).
    ELSE.
      out->write( '❌ Fehlende APIs:' ).
      LOOP AT lt_missing_apis INTO DATA(lv_missing).
        out->write( |  - { lv_missing }| ).
      ENDLOOP.
    ENDIF.
  ENDMETHOD.
ENDCLASS.

Zusammenfassung

Kriterium	Empfehlung
S/4HANA erweitern	Embedded Steampunk
Eigenständige App	Steampunk (BTP)
S/4HANA-Daten + eigene Release-Zyklen	Hybrid (beide)
Schnellster Start mit S/4-Lizenz	Embedded Steampunk
Multi-Cloud SaaS	Steampunk (BTP)
Clean Core bewahren	Embedded Steampunk
Partner-/Kundenportal	Steampunk (BTP)

Weiterführende Themen

ABAP Cloud in S/4HANA Public Cloud - Deep Dive Embedded Steampunk
Developer Extensibility - Erweiterungsmechanismen
Wrapper-Klassen - Classic APIs für ABAP Cloud
RAP Basics - Grundlagen des RESTful Application Programming Model
Clean ABAP - Coding Guidelines für wartbaren Code