gCTS : Git-enabled Change and Transport System

Catégorie

DevOps

Publié

13. Feb. 2026

Auteur

gCTS (Git-enabled Change and Transport System) revolutionne la gestion des transports dans SAP ABAP en utilisant Git comme systeme de controle de version central. Ainsi, les pratiques DevOps modernes comme le branching, les pull requests et le CI/CD deviennent possibles pour le developpement ABAP.

Qu’est-ce que gCTS ?

gCTS connecte le systeme de transport SAP classique avec les repositories Git. Au lieu de deplacer des ordres de transport entre les systemes, les objets ABAP sont stockes sous forme de fichiers dans Git et synchronises via des operations Git.

Aspect	CTS classique	gCTS
Versionnement	Ordres de transport	Commits Git
Branching	Impossible	Branching complet
Comparaison	Limitee	Diff entre commits/branches
Collaboration	Limitee	Pull Requests, Code Review
Historique	Logs de transport	Historique Git complet
Rollback	Manuel	Git Revert/Reset
CI/CD	Difficile	Integration native
Outillage	Specifique SAP	Outils Git standard

Vue d’ensemble de l’architecture

+-----------------------------------------------------------------------+
|                        Paysage de developpement                         |
|                                                                        |
|  +-------------+    +-------------+    +-------------+                 |
|  |     DEV     |    |     QAS     |    |     PRD     |                 |
|  |   Systeme   |    |   Systeme   |    |   Systeme   |                 |
|  |             |    |             |    |             |                 |
|  |  +-------+  |    |  +-------+  |    |  +-------+  |                 |
|  |  | gCTS  |  |    |  | gCTS  |  |    |  | gCTS  |  |                 |
|  |  |Client |  |    |  |Client |  |    |  |Client |  |                 |
|  |  +---+---+  |    |  +---+---+  |    |  +---+---+  |                 |
|  +------+------+    +------+------+    +------+------+                 |
|         |                  |                  |                        |
|         +--------+---------+--------+---------+                        |
|                  |                  |                                  |
|             Push |                  | Pull                             |
|                  v                  v                                  |
|          +-------------------------------+                             |
|          |        Repository Git         |                             |
|          |   (GitHub / GitLab / etc.)    |                             |
|          |                               |                             |
|          |  main ------+---------------  |                             |
|          |             |                 |                             |
|          |  feature/* -+-- branch --     |                             |
|          |                               |                             |
|          +-------------------------------+                             |
+-----------------------------------------------------------------------+

Avantages de gCTS

Perspective developpeur

Feature Branches : Developpement isole de nouvelles fonctionnalites
Pull Requests : Code review avant l’integration
Historique Git : Tracabilite complete de tous les changements
Comparaisons : Diffs faciles entre versions
Outils locaux : Utilisation de VS Code, clients Git, etc.

Perspective operations

Automatisation : Pipelines CI/CD pour tests et deploiements
Rollback : Retour simple aux versions anterieures
Strategies de branching : GitFlow, Trunk-based Development
Conformite : Piste d’audit via l’historique Git
Multi-systeme : Deploiements coherents sur les paysages systemes

Setup et configuration

Prerequis

SAP S/4HANA ou SAP BTP ABAP Environment
Repository Git (GitHub, GitLab, Azure DevOps, Bitbucket)
Certificats SSL pour le serveur Git
Autorisations : S_CTS_ADMI, S_CTS_SADM

1. Importer les certificats SSL

Les certificats SSL du serveur Git doivent d’abord etre importes :

Transaction: STRUST

1. Ouvrir SSL Client (Standard)
2. Importer le certificat:
   - GitHub: github.com
   - GitLab: gitlab.com (ou votre propre domaine)
3. Actualiser la liste des certificats
4. Sauvegarder

2. Creer un repository gCTS

Dans la transaction SE80 ou GCTS_MAINT (App Fiori) :

+--------------------------------------------------------------+
|  Configuration du Repository                                   |
+--------------------------------------------------------------+
|                                                               |
|  Nom du Repository:    Z_MY_PROJECT                           |
|  URL Distante:         https://github.com/company/my-project.git|
|  Branche:              main                                   |
|                                                               |
|  Authentification:                                            |
|  o Authentification basique                                   |
|  * Base sur token (recommande)                                |
|                                                               |
|  Nom d'utilisateur:    github-service-user                    |
|  Token:                ghp_xxxxxxxxxxxx                       |
|                                                               |
|  vSID (Virtual System ID): DEV                                |
|                                                               |
+--------------------------------------------------------------+

3. Appel API du repository

gCTS peut aussi etre configure via l’API REST :

CLASS zcl_gcts_setup DEFINITION
  PUBLIC FINAL
  CREATE PUBLIC.

  PUBLIC SECTION.
    METHODS create_repository
      IMPORTING
        iv_repository_name TYPE string
        iv_remote_url      TYPE string
        iv_branch          TYPE string DEFAULT 'main"
      RAISING
        cx_web_http_client_error.
ENDCLASS.

CLASS zcl_gcts_setup IMPLEMENTATION.
  METHOD create_repository.
    DATA(lo_destination) = cl_http_destination_provider=>create_by_url(
      i_url = |http://localhost:50000/sap/bc/cts_abapvcs/repository| ).

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

    " Creer le corps de la requete
    DATA: BEGIN OF ls_request,
            repository TYPE string,
            url        TYPE string,
            branch     TYPE string,
            role       TYPE string VALUE 'SOURCE',
          END OF ls_request.

    ls_request-repository = iv_repository_name.
    ls_request-url = iv_remote_url.
    ls_request-branch = iv_branch.

    DATA(lv_json) = /ui2/cl_json=>serialize(
      data        = ls_request
      compress    = abap_true
      pretty_name = /ui2/cl_json=>pretty_mode-camel_case ).

    DATA(lo_request) = lo_client->get_http_request( ).
    lo_request->set_header_field( i_name = 'Content-Type' i_value = 'application/json' ).
    lo_request->set_text( lv_json ).

    DATA(lo_response) = lo_client->execute( if_web_http_client=>post ).

    IF lo_response->get_status( )-code <> 201.
      " Gestion des erreurs
      DATA(lv_error) = lo_response->get_text( ).
      RAISE EXCEPTION TYPE cx_web_http_client_error.
    ENDIF.

    lo_client->close( ).
  ENDMETHOD.
ENDCLASS.

4. Lier le package ABAP au repository

" Connecter le package Z_MY_PACKAGE au repository gCTS
" Cela se fait dans SE80 ou via l'API

DATA: BEGIN OF ls_link,
        package    TYPE devclass VALUE 'Z_MY_PACKAGE',
        repository TYPE string VALUE 'Z_MY_PROJECT',
      END OF ls_link.

Workflow Git avec gCTS

Creer un commit

Apres des modifications sur des objets ABAP, celles-ci peuvent etre committees :

+--------------------------------------------------------------+
|  Dialogue Commit                                               |
+--------------------------------------------------------------+
|                                                               |
|  Objets modifies:                                             |
|  [x] ZCL_CUSTOMER_SERVICE    (Classe)                         |
|  [x] ZI_CUSTOMER             (CDS View)                       |
|  [x] ZC_CUSTOMER             (CDS Projection)                 |
|  [ ] ZCL_TEST_HELPER         (Classe)                         |
|                                                               |
|  Message de commit:                                           |
|  +----------------------------------------------------+       |
|  | feat: API Client etendue                           |       |
|  |                                                    |       |
|  | - Nouvelle methode get_customer_orders ajoutee     |       |
|  | - CDS View etendue avec association Orderhistory   |       |
|  | - Tests unitaires ajoutes                          |       |
|  +----------------------------------------------------+       |
|                                                               |
|  [ Commit ]  [ Commit & Push ]  [ Annuler ]                   |
|                                                               |
+--------------------------------------------------------------+

Push, Pull et Checkout

Push - Transferer les commits locaux vers le repository distant :

METHOD push_changes.
  " Appeler l'API REST gCTS
  DATA(lo_client) = create_gcts_client( ).

  DATA(lo_request) = lo_client->get_http_request( ).
  lo_request->set_uri_path(
    |/sap/bc/cts_abapvcs/repository/{ mv_repository }/push| ).

  DATA(lo_response) = lo_client->execute( if_web_http_client=>post ).

  IF lo_response->get_status( )-code = 200.
    " Push reussi
    DATA(lv_result) = lo_response->get_text( ).
  ENDIF.

  lo_client->close( ).
ENDMETHOD.

Pull - Recuperer les modifications du repository distant :

METHOD pull_changes.
  DATA(lo_client) = create_gcts_client( ).

  DATA(lo_request) = lo_client->get_http_request( ).
  lo_request->set_uri_path(
    |/sap/bc/cts_abapvcs/repository/{ mv_repository }/pull| ).

  DATA(lo_response) = lo_client->execute( if_web_http_client=>post ).

  IF lo_response->get_status( )-code = 200.
    " Pull reussi - Les objets ABAP sont mis a jour
  ENDIF.

  lo_client->close( ).
ENDMETHOD.

Changer de branche (Checkout) :

METHOD checkout_branch.
  DATA(lo_client) = create_gcts_client( ).

  DATA: BEGIN OF ls_request,
          branch TYPE string,
        END OF ls_request.
  ls_request-branch = iv_branch_name.

  DATA(lv_json) = /ui2/cl_json=>serialize( data = ls_request compress = abap_true ).

  DATA(lo_request) = lo_client->get_http_request( ).
  lo_request->set_uri_path(
    |/sap/bc/cts_abapvcs/repository/{ mv_repository }/checkout| ).
  lo_request->set_header_field( i_name = 'Content-Type' i_value = 'application/json' ).
  lo_request->set_text( lv_json ).

  DATA(lo_response) = lo_client->execute( if_web_http_client=>post ).
  lo_client->close( ).
ENDMETHOD.

Strategies de branching

GitFlow pour ABAP

main (Production)
|
+-- release/1.0 ------------------------------> PRD
|   |
+-- develop -----------------------------------> QAS
|   |
|   +-- feature/customer-api -----------------> DEV
|   |   |
|   |   +-- Merge via Pull Request
|   |
|   +-- feature/order-workflow ---------------> DEV
|
+-- hotfix/fix-calculation -------------------> Merge vers main & develop

Trunk-based Development

main
|
+-- commit A ----> Auto-Deploy DEV
+-- commit B ----> Auto-Deploy DEV
+-- commit C ----> Auto-Deploy DEV
|
+-- Release Tag v1.0 ----> Deploy QAS ----> Deploy PRD

Workflow Feature-Branch

Workflow typique pour une fonctionnalite :

# 1. Creer une feature-branch (dans l'UI gCTS ou l'API)
Branch: feature/new-customer-api

# 2. Developpement dans le systeme DEV
# - Modifier le code
# - Ecrire les tests
# - Creer les commits

# 3. Push vers le distant
git push origin feature/new-customer-api

# 4. Creer une Pull Request (GitHub/GitLab)
# - Code Review
# - Tests CI/CD
# - Approbation

# 5. Merge dans develop/main
# - Automatiquement ou manuellement

# 6. Pull dans le systeme QAS/PRD
# - Operation Pull gCTS
# - Les objets sont mis a jour

Integration avec GitHub/GitLab

GitHub Actions pour ABAP

Creer un pipeline pour des tests automatises :

name: ABAP CI/CD

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main, develop ]

jobs:
  abap-unit-tests:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v4

    - name: Run ABAP Unit Tests
      uses: sap/abap-ci-action@v1
      with:
        abap-endpoint: ${{ secrets.ABAP_ENDPOINT }}
        username: ${{ secrets.ABAP_USER }}
        password: ${{ secrets.ABAP_PASSWORD }}
        packages: 'Z_MY_PACKAGE"

    - name: Run ATC Checks
      uses: sap/abap-atc-action@v1
      with:
        abap-endpoint: ${{ secrets.ABAP_ENDPOINT }}
        username: ${{ secrets.ABAP_USER }}
        password: ${{ secrets.ABAP_PASSWORD }}
        packages: 'Z_MY_PACKAGE"
        variant: 'Z_CI_CHECKS"

    - name: Deploy to QAS
      if: github.ref == 'refs/heads/main"
      run: |
        curl -X POST \
          "${{ secrets.QAS_ENDPOINT }}/sap/bc/cts_abapvcs/repository/Z_MY_PROJECT/pull" \
          -u "${{ secrets.ABAP_USER }}:${{ secrets.ABAP_PASSWORD }}"

Comparaison : gCTS vs. abapGit

Fonctionnalite	gCTS	abapGit
Support SAP	Officiellement par SAP	Projet communautaire
Integration	Native dans le CTS	Outil autonome
Objets de transport	Completement supporte	Quelques limitations
Paysage systeme	Integre	Gestion separee
Open Source	Non	Oui
Flexibilite	Workflows standard	Hautement personnalisable
Setup	Complexe	Plus simple
Courbe d’apprentissage	Plus raide	Plus plate

Recommandation :

gCTS : Pour les paysages systemes productifs avec exigences de support Enterprise
abapGit : Pour les projets open-source, prototypes ou quand une flexibilite maximale est necessaire

Depannage

Problemes frequents

Erreur de certificat SSL :

Erreur: SSL certificate verification failed
Solution: Importer le certificat dans STRUST (voir Setup)

Erreur d’authentification :

Erreur: 401 Unauthorized
Solution:
- Verifier les autorisations du token (repo, write:packages)
- Mettre a jour le nom d'utilisateur/token dans la configuration gCTS

Conflits de merge :

Erreur: Cannot pull - conflicts detected
Solution:
1. Resoudre les conflits dans le repository Git
2. Executer Pull a nouveau
3. Eventuellement rejeter les modifications locales et pull a nouveau

Verrous d’objets :

Erreur: Object is locked by another user
Solution:
1. Verifier/liberer le verrou dans SM12
2. Executer Pull a nouveau

Logs et diagnostic

" Recuperer les logs gCTS
METHOD get_repository_logs.
  DATA(lo_client) = create_gcts_client( ).

  DATA(lo_request) = lo_client->get_http_request( ).
  lo_request->set_uri_path(
    |/sap/bc/cts_abapvcs/repository/{ iv_repository }/log| ).

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

  IF lo_response->get_status( )-code = 200.
    rv_logs = lo_response->get_text( ).
  ENDIF.

  lo_client->close( ).
ENDMETHOD.

Bonnes pratiques

Theme	Recommandation
Messages de commit	Utiliser les commits conventionnels (feat:, fix:, docs:, etc.)
Branching	Feature-branches pour le developpement isole
Code Review	Pull Requests avec au moins un reviewer
CI/CD	Tests automatises avant chaque merge
Tagging	Taguer les releases avec versionnement semantique
Documentation	Maintenir README.md et CHANGELOG.md
Secrets	Gerer les tokens et mots de passe dans Secrets
Backup	Le repository Git est la sauvegarde - pull regulierement
Formation	Former l’equipe aux bases de Git
Migration	Migrer progressivement de CTS vers gCTS

Sujets complementaires

CI/CD avec ABAP Cloud - Pipelines automatises
ABAP Cleaner - Automatiser la qualite du code
ADT Trucs & Astuces - Developpement efficace