GitOps pour mainframe

GitOps pour mainframe : apporter un contrôle de version moderne à z/OS

La nouvelle développeuse intègre l'équipe mainframe. Forte de cinq ans d'expérience en développement de microservices Java avec Git, GitHub, les pull requests, les revues de code et les pipelines CI/CD, elle maîtrise la création de branches de fonctionnalités, la soumission de pull requests, le suivi des tests automatisés, l'obtention de retours de ses collègues et la fusion une fois les tests réussis. Dès son premier jour dans l'équipe mainframe, elle découvre le workflow : ouvrir ISPF, accéder au PDS source, modifier directement le membre, l'enregistrer, soumettre le JCL compilé et vérifier la sortie système (SYSOUT) pour détecter d'éventuelles erreurs. Il n'y a pas de branches. L'historique se limite aux numéros de séquence des colonnes 1 à 6. Il n'y a pas de pull request. Il n'y a pas de contrôle d'accès automatisé. Si elle et un collègue modifient simultanément le même membre, le second enregistrement écrase le premier sans fusion, sans avertissement, sans conflit : une perte de données silencieuse.

C’est ce flux de travail que GitOps pour mainframe vise à remplacer. Non pas la plateforme z/OS, ni le langage COBOL, ni le traitement transactionnel éprouvé du mainframe avec une disponibilité de 99,9 ...

Générer uniquement les programmes concernés

SMART TS XL identifie chaque programme qui inclut un copybook modifié avant que le pipeline CI ne décide de ce qu'il faut compiler.

EN SAVOIR PLUS…

Que signifie réellement GitOps pour les mainframes ?

GitOps est un modèle opérationnel où Git fait office de source unique de vérité pour le code applicatif et la configuration de l'infrastructure. Chaque modification apportée au système, au code, à la configuration ou à la définition de déploiement est effectuée via un commit Git. Le dépôt Git constitue l'enregistrement officiel ; le système en production est synchronisé pour correspondre aux données définies par Git.

Pour les systèmes mainframe, cela se traduit par un ensemble spécifique d'engagements :

Git est la source faisant autorité pour le code source COBOL. La bibliothèque PDS sur z/OS est un artefact de déploiement ; c'est ce qui est compilé et exécuté en production, et non la source de référence. La source de référence est le dépôt Git. En cas de désaccord entre la bibliothèque PDS et le dépôt Git, c'est Git qui prévaut.

Chaque modification fait l'objet d'une demande de fusion. Aucune modification directe du PDS. Aucune compilation et promotion d'urgence en dehors du flux de travail Git. Une modification urgente est traitée par une demande de fusion accélérée, avec des exigences de validation potentiellement allégées en cas d'urgence réelle, mais elle passe toujours par Git.

Les pipelines automatisés gèrent la compilation et la promotion. Un développeur fusionne sa demande de tirage (PR) ; le pipeline compile les programmes concernés, exécute les tests automatisés et promeut les modules de chargement compilés vers la bibliothèque appropriée. Le développeur n'a pas à soumettre manuellement le JCL de compilation.

L'historique des commits Git constitue la piste d'audit. Chaque modification en production est traçable jusqu'à un commit précis, un auteur précis, une demande de fusion précise et, si le processus de demande de fusion est suivi, un ensemble précis de relecteurs et de résultats de tests.

Il s'agit d'un changement important de flux de travail pour les équipes habituées au développement basé sur ISPF. C'est aussi, de plus en plus, le flux de travail dont les organisations ont besoin pour combler le déficit de compétences : les nouveaux développeurs qui ne connaissent que Git peuvent participer au développement COBOL sans apprendre les conventions de gestion de la bibliothèque ISPF.

Les défis techniques : ce qu’aucun autre article n’explique

Migrer du code source COBOL vers Git n'est pas aussi simple que de créer un dépôt et d'y copier des fichiers. Quatre défis techniques spécifiques à z/OS compliquent la migration :

1. Encodage EBCDIC vs. UTF-8

z/OS stocke les données de caractères en EBCDIC (Extended Binary Coded Decimal Interchange Code), tandis que Git stocke les fichiers en UTF-8. Tout fichier transféré entre le mainframe et un dépôt Git doit être transcodé. Si le transcodage n'est pas effectué correctement, si la page de codes utilisée est incorrecte, si la conversion est incohérente ou si les fichiers sont transférés sans conversion, le code source COBOL est corrompu sans avertissement.

z/OS Unix System Services (USS) sert d'interface : le code source COBOL d'un PDS est transcodé en UTF-8 lors de son écriture sur le système de fichiers USS, permettant ainsi à Git de l'exploiter. Lors du clonage du dépôt Git sur USS, les fichiers sont étiquetés avec leur encodage afin que les outils z/OS sachent comment les interpréter.

bash

# z/OS USS: correctly tag a Git-managed COBOL source file
chtag -t -c IBM-1047 CUSTPROC.cbl

# Verify the tag
ls -T CUSTPROC.cbl
# Output: t IBM-1047   T=on  CUSTPROC.cbl

# The Git checkout hook should apply this automatically
# so developers don't have to tag files manually

2. Source à format fixe et sémantique des colonnes

Les fichiers sources COBOL utilisent une structure à format fixe avec une sémantique spécifique aux colonnes :

Columns 1-6:   Sequence numbers (optional; ISPF editors fill these automatically)
Column 7:      Indicator (* = comment, - = continuation, D = debug line)
Columns 8-11:  Area A (division/section/paragraph names, level numbers 01/77)
Columns 12-72: Area B (executable statements, clauses)
Columns 73-80: Identification (program name, historically used for card identification)

Une comparaison Git de code source COBOL affichant des modifications dans les colonnes 73 à 80 indique généralement des changements de numéro de séquence ou de champ d'identification, et non des modifications fonctionnelles du code. Un outil de comparaison qui ne comprend pas la sémantique de ces colonnes génère du bruit qui masque les modifications réelles. La configuration Git d'un dépôt COBOL doit inclure un .gitattributes qui associe les fichiers COBOL à un pilote de différence qui supprime ou ignore le champ d'identification :

ini

# .gitattributes: configure COBOL-aware diff
*.cbl  diff=cobol
*.cob  diff=cobol
*.cpy  diff=cobol

# .gitconfig (or repo-level config): define the cobol diff driver
[diff "cobol"]
    xfuncname = "^[0-9A-Z][0-9A-Z -]+"
    wordRegex = "[A-Z][A-Z0-9-]+"

3. Contraintes relatives au nom des membres PDS

Les noms des membres PDS sont limités à 8 caractères, en majuscules et alphanumériques. $, #, @Dans Git, le nom du fichier correspond au nom du membre PDS (sans extension, ou avec une extension standard). .cbl (Extension ajoutée par convention). La limite de 8 caractères impose une contrainte de nommage : CUSTUPDT mappe sans problème à un membre PDS ; customer-account-update-processor ne fait pas.

La convention qui fonctionne en pratique : conserver les noms des membres comme nom de fichier de base (8 caractères), ajouter un .cbl extension dans Git pour l'identification de la source, et utilisation de la structure de répertoires dans Git pour fournir l'espace de noms que la dénomination PDS ne peut pas fournir :

repository/
├── CUSTMGMT/          # Logical application group (no PDS equivalent)
│   ├── CUSTUPDT.cbl   # Maps to PDS member CUSTUPDT
│   ├── CUSTINQ.cbl
│   └── CUSTSRCH.cbl
├── COPYBOOKS/
│   ├── CUSTMSTR.cpy   # Maps to PDS member CUSTMSTR
│   └── TRANREC.cpy
└── JCL/
    ├── CUSTNITE.jcl
    └── CUSTMON.jcl

4. Le problème de la source faisant autorité

Lors de la transition d'un développement basé sur PDS vers un développement basé sur Git, PDS et Git contiennent tous deux des copies du code source. Laquelle fait foi ? La réponse doit être sans ambiguïté avant toute modification en production via le nouveau flux de travail.

(cite index=”42-1″>Quel système contient la source faisant autorité : Git, le gestionnaire de bibliothèques ou le résultat du processus de synchronisation ? En cas d’incertitude, les équipes consacrent du temps à résoudre les différences entre les systèmes au lieu de se concentrer sur la création de valeur. Un modèle privilégiant Git apporte une réponse plus claire. Git contient la source faisant autorité et conserve l’historique. Le pipeline utilise cette source pour créer des artefacts testés et traçables en vue du déploiement.

La procédure de transition qui lève cette ambiguïté consiste à établir le dépôt Git comme source faisant autorité à une date précise. Après cette date, toute modification PDS constitue une violation de la politique et doit être signalée et intégrée à Git avant la fin de la journée. Les correctifs urgents bénéficient d'une procédure de demande de fusion accélérée dédiée, et non d'une exception pour les modifications PDS. La période de transition, durant laquelle les deux systèmes sont maintenus, doit être aussi courte que possible, car chaque jour de maintenance simultanée des deux sources représente un risque de divergence.

La chaîne d'outils GitOps pour mainframe

Quatre catégories d'outils connectent Git au pipeline de livraison z/OS :

Gestion des sources et EDI : IBM Developer for z/OS (IDz) propose un EDI traditionnel basé sur Eclipse avec édition de type ISPF et intégration Git. VS Code, avec l’extension Zowe Explorer, offre quant à lui un EDI moderne qui se connecte à z/OS via l’API Zowe, sans nécessiter IDz. Les équipes souhaitant attirer des développeurs maîtrisant les outils modernes privilégient généralement VS Code.

Le framework Zowe : Zowe est un framework open source fournissant des API REST pour z/OS. Il permet d'accéder aux opérations sur les jeux de données, à la soumission de tâches et aux fichiers USS via des interfaces HTTP standardisées, utilisables par les outils CI/CD standards. Sans Zowe (ou un équivalent commercial), il n'existe aucune méthode standard pour un runner GitHub Actions ou un agent Jenkins d'interagir avec z/OS.

IBM Dependency Based Build (DBB) : DBB est l’outil de génération fourni par IBM spécifiquement pour les opérations GitOps sur mainframe. Il comprend les dépendances de compilation COBOL, les copybooks inclus dans chaque programme, les DBD et PSB requis pour les programmes IMS, les BIND nécessaires pour Db2, et utilise cette compréhension des dépendances pour déterminer ce qui doit être compilé lorsqu’un ensemble de fichiers donné est modifié.

Gestion des changements et déploiement : ISPW (CA Brightside), UrbanCode Deploy et Rocket Software ISPW fournissent la gestion de la promotion qui déplace les modules de chargement compilés des bibliothèques de développement à la production en passant par les environnements de test, avec les flux de travail d'approbation et les pistes d'audit requis par les environnements réglementés.

Couche de chaîne d'outilsOption Open Source / IBMAlternative commerciale
IDEVS Code + Zowe ExplorerIBM IDz, Broadcom IDz
Pont API z/OSCouche CLI + API ZoweRocket ConnectZen, CA Brightside
Création d'une orchestrationIBM DBBBMC Compuware Topaz Workbench
Exécuteur CI/CDJenkins, GitHub ActionsAzure DevOps, GitLab CI
Gestion du changementDéploiement de Zowe + DBBISPW, UrbanCode Deploy
Promotion de la sourceFusionner avec la branche principale via GitFlux de travail de promotion ISPW

Le processus : des relations publiques à la production

Le pipeline GitOps de bout en bout pour une modification COBOL couvre la plateforme CI/CD distribuée et l'environnement d'exécution z/OS :

yaml

# GitHub Actions: COBOL GitOps pipeline
name: Mainframe COBOL Pipeline

on:
  pull_request:
    paths:
      - '**/*.cbl'
      - '**/*.cpy'
      - '**/*.jcl'

jobs:
  impact-analysis:
    runs-on: ubuntu-latest
    outputs:
      affected: ${{ steps.analyze.outputs.affected_programs }}
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Identify changed files
        id: changes
        run: |
          CHANGED=$(git diff --name-only origin/main...HEAD \
                    | grep -E '\.(cbl|cpy|jcl)$')
          echo "changed=$CHANGED" >> $GITHUB_OUTPUT

      - name: Analyze dependency scope
        id: analyze
        # SMART TS XL or DBB dependency analysis determines
        # which programs are affected by the changed files
        run: |
          echo "Resolving dependency scope for: ${{ steps.changes.outputs.changed }}"
          # Output: the specific programs that must be compiled/tested

  compile-and-test:
    needs: impact-analysis
    runs-on: [self-hosted, zos-runner]  # Runner with z/OS connectivity
    steps:
      - uses: actions/checkout@v4

      - name: Compile affected COBOL programs (via Zowe + DBB)
        run: |
          zowe dbb build \
            --sourceDir ./CUSTMGMT \
            --affected "${{ needs.impact-analysis.outputs.affected }}" \
            --workDir /u/devops/builds/${{ github.run_id }}

      - name: Run unit tests
        run: |
          zowe zunit run \
            --programs "${{ needs.impact-analysis.outputs.affected }}" \
            --results-dir /u/devops/results/${{ github.run_id }}

      - name: Static compliance check (before promotion)
        run: |
          # Hardcoded credential check, FILE STATUS validation,
          # naming convention compliance
          zowe smart-ts-xl analyze \
            --scope "${{ needs.impact-analysis.outputs.affected }}"

  promote-to-test:
    needs: compile-and-test
    if: github.event_name == 'pull_request' && github.base_ref == 'main'
    runs-on: [self-hosted, zos-runner]
    steps:
      - name: Promote to TEST library (via ISPW)
        run: |
          zowe ispw promote \
            --programs "${{ needs.compile-and-test.outputs.compiled }}" \
            --from DEV --to TEST \
            --change-request ${{ github.event.pull_request.number }}

L'élément critique de ce processus est l'analyse d'impact : déterminer quels programmes COBOL doivent être compilés et testés lorsqu'une demande de tirage modifie un ensemble spécifique de fichiers sources. Sans cette étape, le processus compile soit tout (ce qui est lent et coûteux), soit uniquement les fichiers explicitement modifiés (ce qui entraîne l'omission de programmes dépendant de copybooks modifiés).

Le fossé de la dépendance : pourquoi l'analyse d'impact est la partie la plus difficile

Git sait précisément quels fichiers ont été modifiés lors d'une requête d'extraction. Ce que Git ignore, ce sont les autres programmes affectés par ces modifications.

Une PR qui modifie CUSTMSTR.cpyLe modèle qui définit la structure de la fiche client ne change rien en termes de nombre de fichiers : un seul fichier a été modifié. CUSTMSTR.cpy Ce fichier est inclus par 47 programmes COBOL. Ces 47 programmes doivent être recompilés. Si seul le fichier explicitement modifié est compilé, 46 programmes restent en production avec une définition de copybook qui ne correspond plus à leur binaire compilé. Cette incohérence est silencieuse jusqu'à l'exécution du programme, qui tente alors de lire un enregistrement en utilisant l'ancienne disposition par rapport à des données écrites avec la nouvelle.

C’est là le problème des dépendances dans GitOps sur mainframe : le système de compilation doit connaître le graphe de dépendances pour déterminer la portée de compilation appropriée. IBM DBB résout ce problème pour les nouveaux dépôts en générant une carte de dépendances explicite lors de son processus de compilation. Pour les environnements existants où des milliers de programmes sont antérieurs à DBB, la carte de dépendances initiale doit être construite à partir d’une analyse statique du code source existant.

Les quatre types de dépendances importants pour la définition de la portée des constructions COBOL :

Les instructions COPY constituent la dépendance la plus fréquente. Toute modification apportée à un copybook inclus via COPY nécessite la recompilation de chaque programme qui l'utilise.

Les instructions CALL sont des appels statiques à des sous-programmes. Si l'interface du programme appelé change (paramètres, codes de retour), les appelants peuvent nécessiter une mise à jour et une recompilation.

SQL INCLUDE désigne les programmes SQL intégrés qui incluent des membres DCLGEN (générateurs de classes de données pour les tables Db2). Toute modification du schéma Db2 générant un nouveau DCLGEN nécessite la recompilation de chaque programme l'incluant.

Les références aux ensembles de données JCL DD , les modifications JCL qui font référence à des ensembles de données différents ou utilisent des noms de programme différents affectent le pipeline opérationnel, et pas seulement la compilation du programme.

L'ancien flux de travail comparé au flux de travail Git

AspectFlux de travail basé sur ISPF PDSFlux de travail GitOps basé sur Git
Source de véritéBibliothèque PDS sur z/OSDépôt Git
Mécanisme d'éditionÉditeur ISPF, membre direct de PDSVS Code / IDz avec intégration Git
Suivi des modificationsNuméros de séquence dans les colonnes 1 à 6Historique des commits Git avec auteur, horodatage et message
Édition simultanéeLa deuxième sauvegarde écrase la première (perte silencieuse).Développement basé sur les branches ; détection des conflits de fusion
Examen du codeinformel, en passant devant le bureauDemande de fusion avec processus de revue et d'approbation structurés
Déclencheur de constructionsoumission manuelle de JCLAutomatisé par pipeline lors d'une demande de fusion ou d'une fusion
calcul du périmètre affectéConnaissances manuelles ; tout reconstruire par défautL'analyse des dépendances détermine les programmes affectés
La piste de vérificationJournal des modifications manuelles ; incompletJournal Git + métadonnées des demandes de tirage ; complet et interrogeable
Intégration de nouveaux développeursFormation ISPF requiseIntégration conforme aux normes Git ; environnement de développement intégré moderne
Changements d'urgenceModification directe du PDS ; souvent non suiviProcessus de relations publiques accéléré ; suivi complet

C’est dans la dernière rangée que se concentre le risque opérationnel du flux de travail ISPF : les modifications d’urgence apportées directement aux PDS de production, en contournant le processus de gestion des changements, constituent la source la plus fréquente de modifications de production non suivies et la constatation d’audit la plus fréquente lors des revues de contrôle des changements sur mainframe.

Comment SMART TS XL Permet des opérations Git précises sur mainframe

Le problème de la gestion des dépendances dans le GitOps sur mainframe, l'écart entre « Git sait ce qui a changé » et « le pipeline sait ce qu'il faut compiler », est résolu par l'analyse statique du code source COBOL qui produit le graphe de dépendances.

SMART TS XL's cartographie des dépendances des applications produit le graphe complet des dépendances COPY : chaque copybook, chaque programme qui l’inclut, chaque relation COPY imbriquée et chaque dépendance CALL dans l’ensemble du portefeuille. Lorsqu’une PR modifie CUSTMSTR.cpyLa carte des dépendances génère immédiatement la liste des 47 programmes qui l'incluent, fournissant ainsi au pipeline CI les données de portée de compilation nécessaires pour compiler le bon ensemble de programmes, ni plus, ni moins.

Cette cartographie des dépendances est également essentielle pour sécuriser la migration vers un développement basé sur Git : avant d’établir le dépôt Git comme source principale, il est impératif de connaître l’intégralité du graphe de dépendances afin que la structure initiale du dépôt reflète les relations de dépendance réelles entre les programmes et les copybooks. Une structure de dépôt qui sépare les copybooks des programmes qui les incluent, sans documenter les relations de dépendance, crée un dépôt qui ne se compile correctement que si l’on connaît précisément les dépendances, ce qui va à l’encontre même du principe du contrôle de version.

La fonctionnalité d'analyse statique du code fournit la logique de contrôle avant validation : vérification des programmes modifiés pour détecter les informations d'identification codées en dur, les déclarations FILE STATUS manquantes, la conformité aux conventions d'appellation et les autres contrôles de qualité statiques qui, dans un flux de travail Git, s'exécutent comme des contrôles de PR plutôt que comme des résultats après déploiement.

La fonctionnalité d'analyse d'impact répond à la question posée lors de l'examen des demandes de modification : « Quelle est la portée complète de cette modification ? » Une demande de modification qui modifie un copybook a un impact sur tous les programmes qui l'incluent et sur tous les travaux JCL qui exécutent ces programmes. Rendre cette portée visible dans le contexte de l'examen des demandes de modification, avant la fusion de la modification, permet de prendre des décisions éclairées, de définir un périmètre de tests approprié et d'obtenir les niveaux d'approbation adéquats du comité consultatif des changements.

Le recherche d'entreprise Cette fonctionnalité répond aux exigences de traçabilité : elle permet de retrouver chaque modification apportée à un programme spécifique dans une plage de dates donnée (requête accessible via l’historique Git), chaque programme incluant un copybook spécifique (requête accessible via la carte des dépendances), et chaque programme modifié par un auteur spécifique (requête accessible via Git). La combinaison de l’historique des commits de Git et… SMART TS XLL'analyse structurelle de [nom de l'entreprise] produit la piste d'audit complète et interrogeable dont les équipes de conformité et les comités consultatifs sur le changement ont besoin.

Le dépôt devrait savoir ce que le code sait.

La développeuse qui rejoint l'équipe mainframe avec cinq ans d'expérience Git ne demande pas au mainframe de devenir une plateforme native du cloud. Elle souhaite simplement qu'il prenne en charge les flux de travail utilisés par toute équipe de développement moderne : gestion de versions, revue de code, tests automatisés et traçabilité. Ces flux de travail existent pour des raisons qui s'appliquent aussi bien au COBOL qu'à Java : éviter les doubles modifications et écrasements, créer un historique vérifiable de chaque modification en production, permettre la revue de code avant déploiement et automatiser les tâches répétitives afin que les développeurs puissent se concentrer sur le cœur du métier.

Les défis techniques sont bien réels : encodage EBCDIC, conventions de format de code source fixe, contraintes de nommage PDS, question de la source faisant autorité. Aucun n’est insurmontable. La chaîne d’outils (Zowe, DBB, VS Code avec Zowe Explorer, plateformes de gestion des modifications) en résout la plupart. Le principal défi restant est l’analyse des dépendances, qui permet au pipeline de définir le périmètre approprié lors de la modification d’un composant partagé.

Le mainframe qui gère son code source avec Git, effectue les compilations via un pipeline CI/CD et déploie les applications grâce à un processus de promotion automatisé n'est pas un mainframe différent. Il s'agit du même mainframe, exécutant les mêmes programmes COBOL éprouvés, avec la même fiabilité de 99,9 ...