Steampunk vs. Embedded Steampunk : Comparaison des architectures ABAP Cloud

Catégorie

ABAP Cloud

Publié

14. Feb. 2026

Auteur

Steampunk et Embedded Steampunk sont deux architectures pour le developpement ABAP Cloud. Toutes deux utilisent le meme langage de programmation ABAP Cloud, mais different fondamentalement en termes de deploiement, de stockage des donnees et de cas d’utilisation. Cet article explique les differences et aide a choisir le bon modele.

Clarification des termes

SAP utilise differentes denominations pour ses environnements ABAP Cloud :

Terme	Denomination officielle	Environnement
Steampunk	SAP BTP ABAP Environment	Instance BTP autonome
Embedded Steampunk	S/4HANA Cloud ABAP Environment	Partie de S/4HANA Cloud

Le nom “Steampunk” est apparu comme nom de code interne chez SAP et s’est etabli dans la communaute.

Vue d’ensemble des architectures

Steampunk (BTP ABAP Environment)

┌─────────────────────────────────────────────────────────┐
│                  SAP Business Technology Platform        │
├─────────────────────────────────────────────────────────┤
│  ┌────────────────────────────────────────────────────┐ │
│  │           BTP ABAP Environment                     │ │
│  │  ┌────────────────┬───────────────────────────┐   │ │
│  │  │  ABAP Runtime  │    SAP HANA Database      │   │ │
│  │  │                │    (dedie)                │   │ │
│  │  │  - RAP         │                           │   │ │
│  │  │  - CDS         │    ┌─────────────────┐    │   │ │
│  │  │  - ABAP Cloud  │    │  Donnees propres│    │   │ │
│  │  │                │    │  (pas de S/4)   │    │   │ │
│  │  └────────────────┴────┴─────────────────┴────┘   │ │
│  └────────────────────────────────────────────────────┘ │
│                           │                              │
│                    OData / REST APIs                     │
│                           │                              │
│  ┌────────────────────────▼────────────────────────────┐│
│  │              S/4HANA (optionnel)                    ││
│  │         (Integration via APIs)                      ││
│  └─────────────────────────────────────────────────────┘│
└─────────────────────────────────────────────────────────┘

Caracteristiques principales :

Environnement ABAP completement autonome
Base de donnees HANA propre sans donnees S/4HANA
Integration avec S/4HANA uniquement via APIs (Side-by-Side)
Cycles de release independants
Multi-Cloud (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 uniquement          │   │  │ │
│  │  │  │  - RAP Extensions                    │   │  │ │
│  │  │  │  - BAdI Implementations              │   │  │ │
│  │  │  └──────────────────────────────────────┘   │  │ │
│  │  └──────────────────────────────────────────────┘  │ │
│  │                        │                            │ │
│  │  ┌────────────────────▼─────────────────────────┐  │ │
│  │  │         Base de donnees HANA partagee        │  │ │
│  │  │   (Donnees S/4HANA + Tables personnalisees)  │  │ │
│  │  └──────────────────────────────────────────────┘  │ │
│  └────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────┘

Caracteristiques principales :

Partie du systeme S/4HANA Cloud
Acces direct aux donnees S/4HANA via Released APIs
Extension On-Stack du standard
Mises a jour et releases gerees par SAP
Pas de licence supplementaire requise

Comparaison detaillee

Architecture et deploiement

Aspect	Steampunk	Embedded Steampunk
Deploiement	Instance BTP autonome	Partie de S/4HANA Cloud
Base de donnees	Instance HANA propre	BD S/4HANA partagee
Isolation	Completement isole	Dans la stack S/4HANA
Scalabilite	Scalable independamment	Scale avec S/4HANA
Multi-Cloud	AWS, Azure, GCP, SAP DC	Datacenters SAP

APIs disponibles et Released Objects

Les deux environnements utilisent le modele ABAP Cloud, mais avec une portee differente :

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 disponibles dans LES DEUX environnements :
    " ═══════════════════════════════════════════════════════

    " 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 existe' ).
    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 UNIQUEMENT dans Embedded Steampunk (S/4HANA) :
    " ═══════════════════════════════════════════════════════

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

    " Ces CDS Views ne sont PAS disponibles dans BTP ABAP Environment
    " car il n'y a pas de donnees S/4HANA !

    out->write( 'Comparaison API terminee' ).
  ENDMETHOD.
ENDCLASS.

Comparaison des Released Objects

Categorie	Steampunk (BTP)	Embedded Steampunk
ABAP Basis	✅ Complet	✅ Complet
XCO Library	✅ Complet	✅ Complet
RAP Runtime	✅ Complet	✅ Complet
Infrastructure CDS	✅ Complet	✅ Complet
S/4HANA Business Objects	❌ Non disponible	✅ Released APIs
I_SalesOrder, I_Customer, etc.	❌	✅
S/4HANA BAdIs	❌	✅ Released BAdIs
S/4HANA Behavior Extensions	❌	✅

Systeme de transport et cycle de vie

┌─────────────────────────────────────────────────────────┐
│              Steampunk (BTP ABAP Environment)            │
├─────────────────────────────────────────────────────────┤
│                                                          │
│  Git Repository (abapGit / gCTS)                        │
│         │                                                │
│         ▼                                                │
│  ┌─────────┐    ┌─────────┐    ┌─────────┐              │
│  │   DEV   │ ─► │   QAS   │ ─► │   PRD   │              │
│  │(Branch 1│    │(Branch 2│    │(Main)   │              │
│  └─────────┘    └─────────┘    └─────────┘              │
│                                                          │
│  ► Paysage auto-gere                                    │
│  ► Strategie de branches flexible                       │
│  ► Integration CI/CD possible                           │
│  ► Cycles de release propres                            │
│                                                          │
└─────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────┐
│        Embedded Steampunk (S/4HANA Cloud)                │
├─────────────────────────────────────────────────────────┤
│                                                          │
│  Software Component (ATO)                               │
│         │                                                │
│         ▼                                                │
│  ┌─────────┐    ┌─────────┐    ┌─────────┐              │
│  │   DEV   │ ─► │   TST   │ ─► │   PRD   │              │
│  │ (fixe)  │    │ (fixe)  │    │ (fixe)  │              │
│  └─────────┘    └─────────┘    └─────────┘              │
│                                                          │
│  ► Paysage gere par SAP                                 │
│  ► Paysage fixe a 3 systemes                            │
│  ► Mises a jour SAP trimestrielles                      │
│  ► Transport via ATO (Adaptation Transport Organizer)   │
│                                                          │
└─────────────────────────────────────────────────────────┘

Cas d’utilisation

Quand utiliser Steampunk (BTP ABAP Environment) ?

Scenarios ideaux :

Nouvelles applications Cloud-Native
- Applications metier autonomes
- Microservices avec backend ABAP
- APIs pour partenaires externes
Solutions SaaS Multi-Tenant
- Produits logiciels propres
- Plateformes cross-clients
Developpement independant de S/4HANA
- Pas de systeme S/4HANA existant
- Cycles de release independants requis
Hub d’integration
- Plateforme d’integration centrale
- Orchestration d’APIs

CLASS zcl_btp_use_case DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    " Exemple : Application SaaS autonome sur 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.
    " Logique metier propre - independante de S/4HANA
    TRY.
        " Parser JSON
        DATA(lo_json) = /ui2/cl_json=>deserialize(
          json = iv_order_json
          jsonx = '' ).

        " Utiliser des tables propres (pas S/4HANA)
        INSERT INTO zorders VALUES @ls_order.

        " Integration avec des backends arbitraires
        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' )
        ).

        " Traitement...
        rv_result = 'SUCCESS'.

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

Quand utiliser Embedded Steampunk (S/4HANA Cloud) ?

Scenarios ideaux :

Extensions S/4HANA
- Custom Fields et logique
- Adaptations de processus
- Implementations BAdI
Integration avec le standard
- Applications propres avec donnees S/4HANA
- Extension des processus standard
- Rapports personnalises sur donnees S/4HANA
Side-by-Side n’est pas une option
- Processus critiques en latence
- Volumes de donnees importants
- Couplage etroit requis
Strategie Clean Core
- Extensions sans modification
- Adaptations compatibles avec les mises a jour

CLASS zcl_embedded_use_case DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    " Exemple : Extension S/4HANA
    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.
    " Acces direct aux donnees S/4HANA via Released APIs
    SELECT SINGLE
      Customer,
      CustomerName,
      CustomerFullName,
      CustomerClassification
    FROM I_Customer
    WHERE Customer = @iv_customer
    INTO @rs_result-customer_data.

    " Commandes du client
    SELECT
      SalesOrder,
      SalesOrderType,
      SalesOrganization,
      NetAmount,
      TransactionCurrency
    FROM I_SalesOrder
    WHERE SoldToParty = @iv_customer
      AND OverallSDProcessStatus <> 'C"
    INTO TABLE @rs_result-open_orders.

    " Combiner avec des tables personnalisees
    SELECT
      inquiry_id,
      subject,
      status,
      priority
    FROM zinquiry
    WHERE customer = @iv_customer
    INTO TABLE @rs_result-custom_inquiries.
  ENDMETHOD.
ENDCLASS.

Matrice de decision

Decision rapide par criteres

Critere	Steampunk	Embedded Steampunk
Donnees S/4HANA directement necessaires		✅
Application autonome	✅
Multi-Cloud requis	✅
Etendre le standard (BAdIs)		✅
Releases independants	✅
Maintenir Clean Core		✅
Developper un produit SaaS	✅
Licence S/4HANA Cloud deja acquise		✅

Arbre de decision

                    ┌─────────────────────────┐
                    │  Avez-vous besoin d'un  │
                    │  acces direct aux       │
                    │  donnees S/4HANA ?      │
                    └───────────┬─────────────┘
                                │
                    ┌───────────┴───────────┐
                    │                       │
                   OUI                     NON
                    │                       │
        ┌───────────▼───────────┐  ┌───────▼────────────┐
        │  La performance/      │  │  Developpez-vous   │
        │  latence est-elle     │  │  un produit        │
        │  critique ?           │  │  propre ?          │
        └───────────┬───────────┘  └───────┬────────────┘
                    │                       │
            ┌───────┴───────┐       ┌───────┴───────┐
            │               │       │               │
           OUI            NON      OUI            NON
            │               │       │               │
            ▼               │       ▼               ▼
    ┌───────────────┐       │ ┌───────────┐ ┌──────────────┐
    │   Embedded    │       │ │ Steampunk │ │  Les deux    │
    │   Steampunk   │       │ │   (BTP)   │ │  possibles   │
    └───────────────┘       │ └───────────┘ │              │
                            │               │  Facteurs :  │
                            │               │  - Licence   │
                            │               │  - Competences│
                            │               │  - Strategie │
                            ▼               └──────────────┘
                    ┌───────────────┐
                    │  Integration  │
                    │  Side-by-Side │
                    │  avec BTP     │
                    │  Steampunk    │
                    └───────────────┘

Scenarios hybrides

Dans la pratique, de nombreuses entreprises combinent les deux approches :

Exemple d’architecture : Configuration entreprise

┌─────────────────────────────────────────────────────────────┐
│                     Architecture entreprise                  │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  ┌────────────────────┐       ┌────────────────────────┐    │
│  │   S/4HANA Cloud    │       │        BTP             │    │
│  │ ┌────────────────┐ │       │ ┌────────────────────┐ │    │
│  │ │Embedded        │ │       │ │  Steampunk         │ │    │
│  │ │Steampunk       │ │◄─────►│ │  (BTP ABAP Env)    │ │    │
│  │ │                │ │  API  │ │                    │ │    │
│  │ │ - Extensions   │ │       │ │ - Hub Integration  │ │    │
│  │ │ - Custom Fields│ │       │ │ - Portail Partenaire│ │   │
│  │ │ - BAdIs        │ │       │ │ - Analytics        │ │    │
│  │ └────────────────┘ │       │ └────────────────────┘ │    │
│  └────────────────────┘       └────────────────────────┘    │
│           │                              │                   │
│           │                              │                   │
│           ▼                              ▼                   │
│  ┌─────────────────────────────────────────────────────┐    │
│  │              Fiori Launchpad / Work Zone            │    │
│  │         (Interface utilisateur unifiee)             │    │
│  └─────────────────────────────────────────────────────┘    │
│                                                              │
└─────────────────────────────────────────────────────────────┘

Communication entre les environnements

CLASS zcl_steampunk_integration DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    " BTP Steampunk : Recuperer des donnees de S/4HANA
    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.
    " Dans BTP Steampunk : Appel API vers S/4HANA Cloud
    TRY.
        " Utiliser Communication Arrangement
        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( ).

        " Traiter JSON
        /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).
        " Gestion des erreurs
    ENDTRY.
  ENDMETHOD.
ENDCLASS.

Migration entre environnements

De Steampunk vers Embedded Steampunk

Lorsqu’une application BTP doit etre integree dans S/4HANA plus tard :

1. Analyse du code
   └─► Quelles APIs sont utilisees ?
   └─► Y a-t-il des dependances vers des services specifiques BTP ?

2. Verifier le modele de donnees
   └─► Les tables peuvent-elles etre migrees vers S/4HANA ?
   └─► Y a-t-il des conflits avec des objets standard ?

3. Configurer le transport
   └─► Configurer le repository gCTS sur S/4HANA
   └─► Cloner le code

4. Adaptations
   └─► Convertir les appels API vers les S/4HANA Released APIs
   └─► Simplifier la logique d'integration (acces DB direct)

5. Test & Go-Live
   └─► Tests de regression complets
   └─► Migration progressive

De Embedded Steampunk vers Steampunk

Lorsqu’une extension S/4HANA doit devenir autonome :

1. Identifier les dependances
   └─► Quels CDS Views S/4HANA sont utilises ?
   └─► Quels BAdIs sont implementes ?

2. Creer une couche API
   └─► Services OData pour l'acces aux donnees S/4HANA
   └─► Integration via Destinations

3. Externaliser les donnees
   └─► Creer des tables propres
   └─► Configurer la replication de donnees (optionnel)

4. Migrer le code
   └─► Utiliser gCTS/abapGit
   └─► Remplacer les acces DB directs par des appels API

5. Configurer la communication
   └─► Communication Arrangements
   └─► Destination Configuration

Couts et licences

Aspect	Steampunk	Embedded Steampunk
Licence de base	Licence BTP separee	Inclus dans S/4HANA Cloud
Facturation	ABAP Compute Units	Partie de la licence S/4
Scalabilite	Pay-as-you-go possible	Capacite fixe
Couts de developpement	Infrastructure propre	Partage avec S/4

Considerations TCO

Steampunk (BTP ABAP Environment) :
├── + Scalabilite flexible
├── + Developpement independant
├── - Couts de licence supplementaires
├── - Administration propre
└── - Effort d'integration pour les donnees S/4

Embedded Steampunk (S/4HANA Cloud) :
├── + Pas de couts supplementaires
├── + Acces direct aux donnees
├── + Infrastructure geree par SAP
├── - Cycles de mise a jour fixes
└── - Moins de flexibilite

Bonnes pratiques

Documenter les criteres de decision

" Documentation de la decision d'architecture
" au format ABAP Doc

"! @title Decision d'architecture : Steampunk vs. Embedded
"!
"! Decision : Embedded Steampunk
"!
"! Raisons :
"! - Acces direct aux donnees de commandes clients requis
"! - Validations critiques en performance
"! - Pas d'infrastructure separee souhaitee
"! - Licence S/4HANA Cloud deja disponible
"!
"! Alternatives evaluees :
"! - BTP Steampunk : Couts d'integration plus eleves
"! - Key User Extensibility : Pas assez flexible
"!
"! Risques :
"! - Dependance aux cycles de mise a jour SAP
"! - Les Released APIs doivent suffire

Valider la disponibilite des APIs

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.
    " Verifier si les APIs requises sont disponibles dans l'environnement cible
    DATA: lt_required_apis TYPE TABLE OF string,
          lt_missing_apis  TYPE TABLE OF string.

    " Liste des APIs requises
    lt_required_apis = VALUE #(
      ( 'I_Customer' )
      ( 'I_SalesOrder' )
      ( 'I_Product' )
      ( 'CL_ABAP_RANDOM' )
      ( 'CL_WEB_HTTP_CLIENT_MANAGER' )
    ).

    " Verifier la disponibilite
    LOOP AT lt_required_apis INTO DATA(lv_api).
      " Verifier les CDS Views
      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.
        " Verifier les classes
        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.

    " Afficher le resultat
    IF lt_missing_apis IS INITIAL.
      out->write( 'Toutes les APIs requises sont disponibles' ).
    ELSE.
      out->write( 'APIs manquantes :' ).
      LOOP AT lt_missing_apis INTO DATA(lv_missing).
        out->write( |  - { lv_missing }| ).
      ENDLOOP.
    ENDIF.
  ENDMETHOD.
ENDCLASS.

Resume

Critere	Recommandation
Etendre S/4HANA	Embedded Steampunk
Application autonome	Steampunk (BTP)
Donnees S/4HANA + cycles de release propres	Hybride (les deux)
Demarrage rapide avec licence S/4	Embedded Steampunk
SaaS Multi-Cloud	Steampunk (BTP)
Preserver Clean Core	Embedded Steampunk
Portail partenaire/client	Steampunk (BTP)

Sujets connexes

ABAP Cloud dans S/4HANA Public Cloud - Deep Dive Embedded Steampunk
Developer Extensibility - Mecanismes d’extension
Classes Wrapper - APIs Classic pour ABAP Cloud
RAP Basics - Fondamentaux du RESTful Application Programming Model
Clean ABAP - Guidelines de codage pour un code maintenable