Premiers pas vers Manzan

Aujourd’hui vous verrez comment installer, configurer et superviser les messages INQ de QSYSOPR avec Manzan pour les envoyer par mail.

Qu’est ce que Manzan ?

Manzan est un observability stack* (codé en Java) permettant de faciliter la supervisation d’une plateforme IBMi en interceptant des messages systèmes puis en les envoyant sur un serveur qui s’occupe de les rédiriger vers les destinations configurées.

*C’est un ensemble d’outils qui permettent de comprendre en profondeur ce qui se passe dans un système informatique en collectant, stockant et analysant ses métriques, logs et événements.

Il permet entre autre de :

  • surveiller les messages système (QSYSOPR, QSYSMSG, QHST)
  • surveiller les jobs (MSGW, CPU, statut, durée…)
  • surveiller les sous‑systèmes
  • surveiller les queue spools
  • surveiller les ressources système (CPU, mémoire, disques)
  • et bien d’autres…
  • déclencher des alertes
  • exécuter des actions automatiques (commandes CL, programmes CL/RPG)
  • exposer les données à Grafana, Prometheus, InfluxDB, etc.

Installation de Manzan

  1. Créer un répertoire « download » sur IBM i (Pour y mettre votre installeur)
  2. Télécharger la dernière version du manzan-installer-v#.jar
    ou avec la commande ci dessous :
    wget https://github.com/ThePrez/Manzan/releases/download/v0.0.X/manzan-installer-v0.0.X.jar
  3. Si vous ne l’avez pas fait directement, transférer le .jar vers IBM i
  4. Lancez l’installeur avec : java -jar manzan-installer-v0.0.X.jar
  5. Configurez vos fichiers .ini

(Vous aurez surement besoin de Service commander si vous ne l’avez pas déjà)

Fichiers de configuration:

Il en existe 3 :

  • app.ini pour la configuration générale de Manzan (rien à toucher généralement)
  • data.ini pour configurer les sources et les données à traiter
  • dests.ini pour configurer les différentes sorties que Manzan va utiliser


app.ini

Vous n’aurez rien besoin de faire particulièrement sur celui ci à part les lignes ci dessous ci ce n’est pas déjà fait :

Vous indiquez ici la bibliothèque d’installation de Manzan

[install]
library=MANZAN


data.ini

Ce fichier contiendra toutes les sources que vous voudrez surveiller avec le choix du format

exemple de surveillance des messages INQ de la message queue QSYSOPR:

fichier data.ini :

[watcher_messages_INQ]
type=sql
query=SELECT MESSAGE_ID, MESSAGE_TEXT, FROM_JOB FROM QSYS2.MESSAGE_QUEUE_INFO WHERE MESSAGE_QUEUE_NAME = 'QSYSOPR' AND MESSAGE_TYPE = 'INQUIRY' AND ASSOCIATED_MESSAGE_KEY IS NULL
interval=600000
destinations=email_example
format={"msg_id": "$MESSAGE_ID$", "alerte": "$MESSAGE_TEXT$", "job_bloque": "$FROM_JOB$"}

[watcher_messages_INQ] : un id complètement arbitraire, vous pouvez le renommer comme bon vous semble

type : le type est sélectionné en fonction de la donnée à analyser. Au dessus par exemple on souhaite faire une requête pour récupérer les bonnes lignes à regarder c’est donc SQL.

query : requête SQL pour regarder les messages INQUIRY dans QSYSOPR

interval : l’interval (en ms) qui séparera chaque itération de votre requête (ici toutes les 10 minutes)

destinations : un lien vers votre fichier dests.ini dans lequel vous configurerez comment envoyer les données sélectionnées vers la/les sources que vous préciserez ici. Gardez aussi en mémoire qu’il peux y avoir plusieurs destinations séparées par des virugles.

format : Ce format de message sera son « corps ». Ce sera la façon dont vous verrez les données une fois transmises.

   (à noter que toutes vos données doivent être bornées par des $)


dests.ini

Ce fichier est composé de nombreuses sections qui définissent des destinations de données. Une destination est en fait un emplacement (comme un service) vers lequel les données peuvent être envoyées. Dans cet exemple j’utilise Ethereal Email qui permet d’avoir une boite mail jetable, utile pour les tests

fichier dests.ini

[email_example]
type=smtp
format=Nouveau message!! \n\n$MESSAGE_ID$ $MESSAGE_TIMESTAMP$ \n(severity $SEVERITY$): \n message : $MESSAGE_TEXT$ \n job : $FROM_JOB$
server=smtp.ethereal.email
port=587
username=exemple@ethereal.email
password=pm***********
mail.smtp.starttls.enable=true
subject=Nouveau message dans QSYSOPR
from=exemple@ethereal.email
to=exemple@ethereal.email

[email_exemple] : pareil que dans data.ini

type : même fonctionnement que dans data.ini mais cette fois ce sera la méthode d’envoi de données. Tous les types sont répertoriés ici : Types de destinations

format : même principe que dans data.ini sauf qu’ici, le format n’est pas à envoyer à destinations mais sera le format final que vous verrez, ce sera le formattage de votre « log » personnalisé (exemple en dessous)

serveur : explicitement le serveur vers lequel vous voulez envoyer votre message (ici Ethereal Email)

username : votre adresse mail

password : un identifiant propre à votre mail, vous est donnée directement à la connexion sur des services comme Ethereal Email, sinon à chercher dans vos paramètres de sécurité sur les domaine comme gmail ou hotmail.

port : port de sortie (pour envoyer) du service de mail choisi, en général ce sera toujours 587

mail.smtp.starttls.enable : sert à activer ou non le chiffrage de vos données sur le serveur

subject : l’objet du mail

from et to : respectivement l’email de l’envoyeur et du destinataire (peut être le même)

les paramètres changent en fonction de la destination, ils sont très explicites et bien documentés avec beaucoup d’exemples dans la documentation dans la catégorie des Destinations.


🚨Faites attention !

La QSYSOPR envoie beaucoup de messages qui ne sont pas INQUIRY donc pensez bien à faire la requête sur les messages INQ (comme dans les exemples ici). Sinon si vous utilisez votre boite mail, vous serez surement spam, c’est pourquoi dans cet exemple nous utilisons un email jetable en ligne.


Comment lancer Manzan ?

Il faut se mettre au bon endroit sur votre IFS, dans le répertoire où vous avez effectué l’installation de manzan en général. Soit vous y naviguez manuellement soit par VSCode vous avez cette option « Open Terminal Here » :

Ensuite une fois sur votre terminal vous taperez : sc start manzan

Vous devriez avoir ce message en vert s’afficher au bout de quelques secondes vous indiquant que c’est lancé.

(Mon Warning est dû au fait que j’ai gardé mon ancien .yaml en .old en tant que backup, vous ne devriez pas avoir ce message)

Pour être sûr que Manzan est lancé, tapez : sc check manzan
et vous devriez voir cela :

Si vous avez des problèmes ou que le serveur vous fait des timeout regardez les .yaml

le premier se trouve dans ./.sc/services/manzan.yaml

le 2e se trouve dans /opt/manzan/bin/manzan.yaml

Pensez à déclarer vos variables d’environnements comme :

MANZAN_MESSAGING_PREFERENCE=SQL MANZAN_SOCKET_PORT=8888 (prenez un port qui n’est pas déjà pris) export LC_ALL=FR_FR.UTF-8 à mettre dans votre .profile

Voici nos fichiers d’exemples

.profile

export PATH=/QOpenSys/pkgs/bin:$PATH
export LC_ALL=FR_FR.UTF-8

./.sc/services/manzan.yaml

name: Manzan
dir: /QOpenSys/etc/manzan
start_cmd: /opt/manzan/bin/manzan
check_alive: manzan
batch_mode: 'true'
sbmjob_jobname: manzan
sbmjob_opts: JOBQ(QUSRNOMAX)
environment_vars:
  - "PATH=/QOpenSys/pkgs/bin:/QOpenSys/usr/bin"
  - "MANZAN_MESSAGING_PREFERENCE=SQL"
  - "MANZAN_SOCKET_PORT=8096"
  - "MANZAN_DEBUG_LEVEL=3"

Exemples de résultats dans les mails :

Commande pour tester avec un envoie de message INQUIRY dans QSYSOPR via 5250 :

SNDPGMMSG MSG('Test message Manzan') TOMSGQ(QSYSOPR) MSGTYPE(*INQ)

, IBM i en 2026 : la pénurie de compétences, une réalité désormais impossible à ignorer

En 2026, un fait majeur ressort du IBM i Marketplace Survey : la pénurie de compétences IBM i devient la préoccupation n°1, devant la cybersécurité, pour la première fois en presque dix ans.

Les départs à la retraite s’accélèrent, les équipes se réduisent, les projets se complexifient… et le renouvellement est insuffisant. Pourtant, tout n’est pas sombre : l’écosystème évolue, de nouvelles approches émergent, et certains pays — comme la France — disposent d’atouts uniques pour former rapidement.


Un départ massif des experts… et un vivier insuffisant pour les remplacer

La démographie joue contre les organisations : une large majorité des spécialistes IBM i ont plus de 50 ans, beaucoup étant déjà partis ou proches de la retraite. Pendant ce temps, le monde académique continue d’ignorer RPG et IBM i.

Résultat :

  • une perte d’expertise métier cumulée,
  • des applications critiques peu documentées,
  • et un risque croissant de dépendance à un ou deux profils clés.

Cette situation explique pourquoi 69 % des entreprises déclarent la compétence IBM i comme souci majeur.


La France dispose pourtant d’un avantage rare pour former rapidement

Sans trop appuyer le trait, il faut reconnaître un point souvent méconnu : la France bénéficie d’un écosystème particulièrement performant pour former rapidement de nouveaux talents. Nous profitons en effet d’un ensemble de dispositifs privés et publics qui, fait notable, savent travailler en synergie.

Les POEI, organisées depuis plus de dix ans sous de multiples formats, en sont une illustration concrète : elles permettent de financer une formation ciblée avant embauche pour répondre à un besoin métier précis. S’y ajoutent un foisonnement d’initiatives autour de l’alternance, ainsi qu’une offre de formation professionnelle soutenue par les OPCO, qui facilite la montée en compétences sur des technologies spécifiques.

Cet ensemble de mécanismes donne aux entreprises la possibilité de former un candidat avant embauche afin de combler un écart de compétences — une approche parfaitement alignée avec les réalités IBM i, où l’on privilégie depuis longtemps la montée en compétences plutôt que la quête du “profil idéal introuvable”.

On observe toutefois une absence notable de formations institutionnelles (lycées professionnels, BUT, universités, écoles d’informatique) portant sur IBM i ou RPG. Cela limite naturellement la visibilité du domaine auprès des jeunes.

Cela ne règle pas tout, mais c’est un avantage concret pour les organisations françaises qui souhaitent attirer et intégrer de nouveaux talents dans l’écosystème IBM i.


Quand l’IA ralentit l’entrée des jeunes dans l’IT… y compris sur IBM i

Un autre phénomène joue en arrière‑plan en 2026 : l’IA fait baisser les embauches juniors dans l’ensemble du secteur IT.

Selon Korn Ferry, 37 % des entreprises prévoient de remplacer des postes d’entrée de carrière par l’IA. Gartner observe la même tendance : les entreprises recourent davantage à l’IA pour les tâches “low value”, ce qui réduit mécaniquement les opportunités d’entrée des jeunes diplômés.

Sans dramatiser, cela signifie que :

  • le renouvellement naturel des compétences pourrait ralentir,
  • les experts actuels deviennent encore plus stratégiques,
  • et il sera mécaniquement plus difficile de les remplacer lorsqu’ils partiront.

Pour IBM i, déjà confronté à un déficit de nouveaux talents, cet effet secondaire de l’IA mérite d’être surveillé.


Mais où sont les “centaines” ou “milliers” de postes IBM i dont on parle ?

La question revient souvent, et elle est légitime : si les besoins sont si énormes, pourquoi ne voit‑on pas une avalanche d’offres d’emploi IBM i ?

Quelques éléments de réponse — sans exagération :

1. Un besoin réel mais très fragmenté

Les organisations IBM i fonctionnent souvent avec de petites équipes (3–5 personnes), un modèle stable depuis des années selon la Marketplace Survey.
Elles recrutent surtout au fil des départs, pas par vagues massives.

2. Un marché qui “tient” avec ce qu’il a

Les entreprises retardent les modernisations, réorganisent en interne, externalisent ponctuellement ou repoussent le recrutement.
Le marché de l’emploi IBM i montre d’ailleurs une embauche lente, malgré la hausse des salaires, comme observé dans les analyses emploi de 2024–2025.

3. Une demande qui change de nature

Les entreprises ne cherchent plus seulement des “développeurs RPG”, mais des profils capables de :

  • faire du Git,
  • moderniser le code,
  • exposer des API,
  • intégrer des outils open source ou cloud.

La demande existe, mais elle est hybride, moins visible, et souvent absorbée par de la prestation.

4. Une partie du besoin est transférée vers des MSP ou vers le cloud

Le survey 2026 montre une montée du cloud et des providers de services, utilisés pour déporter une partie des responsabilités (maintenance, HA/DR, sécurité).
Cela réduit mécaniquement le volume d’offres en direct.


Conclusion : un vrai défi… mais aussi une fenêtre d’opportunité

L’écosystème IBM i fait face à une équation complexe :

  • Une pénurie de compétences reconnue et mesurée (69 % des organisations).
  • Une dynamique mondiale où l’IA réduit les postes juniors, freinant l’arrivée des nouveaux talents.
  • Une demande réelle mais diffuse, structurée par du remplacement plutôt que du recrutement massif.

Pour autant, les solutions existent :

  • programmes de formation internes,
  • mentorat et documentation,
  • modernisation technique,
  • et, en France, un atout concret avec la POEI qui permet d’intégrer et de former des jeunes profils rapidement.

La plateforme IBM i reste robuste, moderne et stratégique. Désormais, l’enjeu est clair : organiser le renouvellement des compétences plutôt que l’attendre.

Nous avons bien d’autres thèmes à prendre en compte, comme une communauté active et engagée, mais nous en reparlerons !

Parlez REXX sur IBMi

REXX (Restructured Extended Executor) est un langage de script interprété créé par IBM, bien connu pour les « Roger » qui ont sévit sous OS2.
Il est conçu pour être facile à lire et facile à apprendre, tout en étant très puissant pour l’automatisation.

Sur IBMi, il est utilisé pour :
Automatiser des tâches système
Créer des utilitaires interactifs
Prototyper rapidement
Faire du traitement de texte et de données

Ces points forts sont :
Très rapide à écrire, idéal pour du scripting jetable
Permet d’appeler directement des commandes système sans compiler un programme
Peut servir de « colle » entre RPG, CL, SQL et PASE/QShell
Permet de faire des tests d’appels, des scripts de migration, des reprises de données.

Comment ca marche?

Vous devez créer un fichier source qui contiendra les scripts à exécuter

CRTSRCPF FILE(MALIB/QRXSRC) RCDLEN(112) TEXT(‘Sources REXX’)

Vous devez saisir vos scripts ici REXX01

/* REXX / / Boucle interactive jusqu’à ce que l’utilisateur tape ‘FIN’ */

DO FOREVER
SAY « Entrez une commande CL (ou FIN pour quitter) : »
PULL CMD
IF CMD = « FIN » THEN LEAVE
ADDRESS ‘COMMAND’ CMD
END

Ce scripte exécutera des commandes CLP, jusqu’à ce que saisissiez FIN

Pour exécuter ce script :

STRREXPRC SRCMBR(REXX01) SRCFILE(MALIB/QRXSRC)

Remarque :
Le rexx est de moins en moins utilisé mais, il peut encore être utilisé, en effet, il peut aider a du déploiement et de la mise au point, etc…

Pour en savoir plus :

https://en.wikipedia.org/wiki/Rexx

https://www.rexxla.org

Merci à Dilhan pour sa contribution

, , Les profils _NC en V7R6

En V7R6 vous avez de nouveaux profils qui apparaissent avec l’extention _NC

QPGMR_NC
QSECOFR_NC
QSYSOPR_NC
QUSER_NC

C’est des profils qui ne sont pas modifiables, et ils n’ont pas de mot de passe

Et certains services ibm démarrent avec ceux ci

Conclusions :
Attention, par exemple, si vous avez customisé QUSER ou QPGMR vous pouvez avoir des surprises après migration

, , Ajouter des fichiers à une archive ZIP

Vous connaissez tous la commande CPYTOARCF qui permet de Zipper un fichier

Mais vous ne pouvez pas un fois généré lui ajouter un fichier !

On va essayer de vous aider

Dans les produits opensys vous avez la commande zip

Vous avez ce répertoire dans votre path (similaire à votre *LIBL)
$

echo $PATH
/QOpenSys/pkgs/bin:/usr/bin:.:/QOpenSys/usr/bin
$

Remarque
Vous pouvez le régler par le fichier .profile

https://www.ibm.com/support/pages/setting-path-environment-variable-include-current-working-directory-qshell

Vous pouvez donc zipper sous QSH ou QP2TERM

exemple

$

zip archive.zip analyse.csv
adding: analyse.csv (deflated 84%)
$

et par défaut si vous zippez sur une archive existante il ajoute

zip archive.zip xmlversion.txt
adding: xmlversion.txt (stored 0%)
$

pour voir le résultat

unzip -l archive.zip
Archive: archive.zip
Length Date Time Name
——— ———- —– —-
9934 2019-03-29 23:44 analyse.csv
17 2019-02-13 10:49 xmlversion.txt
——— ——-
9951 2 files
$

Pour vous aider nous proposons une commande ADDTOARCF que vous pouvez retrouver ici
https://github.com/Plberthoin/PLB/tree/master/GTOOLS/
un CLLE + un CMD

Remarque :

Vous pouvez ajouter une un fichier à un zip généré par CPYTOARCF
Par défaut il créera la l’archive
Vous pouvez indiquer des options si elles sont valides dans la commande Zip
Vous avez un fichier stdout.log dans votre répertoire courant

Simple et efficace !

Comment faire afficher un écran à un traitement batch ?

Les traitements 5250 sont faits pour tourner en interactif, mais pour différentes raisons vous pouvez vouloir les faire tourner en batch :

Pas de login
sécurisation pas de attn request
etc …

Voici un exemple, dans une société ou j’ai travaillé, les unités de productions pouvaient demander un mot de passe à l’astreinte, par exemple la nuit.

La solution la plus simple qu’on avait trouvée était de lui afficher un programme de changement sur son unité écran.

On lui demandait donc son profil utilisateur et son unité écran et on lançait le programme sur celle ci, il pouvait changer son mot de passe directement.

C’est cet exemple que j’ai simplifié qui est ci dessous

le DSPF source

                                                                 
     A                                      DSPSIZ(24 80 *DS3)             
     A                                      CA03(03)                       
     A                                      INDARA                         
     A          R FMT01                                                    
     A*%%TS  SD  20240527  074541  PLB         REL-V7R4M0  5770-WDS        
     A                                  4 20'Réinitialiser un mot de passe'
     A                                  7  2'Utilisateur         :'        
     A                                  8  2'Nouveau mot de passe  :'        
     A                                 22  1'F3=Exit'                      
     A            USER          10A  O  7 26                               
     A            PWD           32A  B  8 26CHECK(LC)                      
     A            DEV           10A  O  4 54                               
     A            TEXTE         30   O 14  3                               

Le CLP source

pgm  (&dev &user)                                                
/*----------------------------------------------------------*/   
/* Ce programme permet de faire afficher un écran en batch  */   
/* vous devez acquérir l'unité écran                         */   
/* pour réinitialiser un mot de passe                        */   
/* sbmjob cmd(call initpwdr (&dev &user) job(QPADEV0001)    */   
/*----------------------------------------------------------*/   
dcl &dev  *char 10                                               
dcl &user *char 10                                               
/* Contrôles existence                      */                   
             CHKOBJ     OBJ(&DEV) OBJTYPE(*DEVD)                 
             MONMSG     MSGID(CPF9801) EXEC(DO)                  
             SNDPGMMSG  MSGID(CPF9898) MSGF(QCPFMSG) +           
                          MSGDTA('L''unité écran doit exister') +
                          MSGTYPE(*ESCAPE)                       
             enddo 
            ALCOBJ     OBJ((&DEV *DEVD *EXCLRD)) WAIT(0)       
            monmsg CPF1002  exec(do)                           
            SNDPGMMSG  MSGID(CPF9898) MSGF(QCPFMSG) +          
                         MSGDTA('Impossible d''allouer l''unité +
                         écran doit exister') MSGTYPE(*ESCAPE) 
            enddo                                                                                            
             CHKOBJ     OBJ(&user) OBJTYPE(*usrprf)              
             MONMSG     MSGID(CPF9801) EXEC(DO)                  
             SNDPGMMSG  MSGID(CPF9898) MSGF(QCPFMSG) MSGDTA('Le +
                          profil utilisateur doit exister') +         
                          MSGTYPE(*ESCAPE)                            
             enddo                                                    
 /* Lancement du programme sur l'écran remote  */                      
             SBMJOB     CMD(CALL PGM(INITPWDR) PARM((&DEV) (&USER))) +
                          JOB(&DEV) JOBQ(QSYSNOMAX)  
             SNDPGMMSG  MSGID(CPF9898) MSGF(QCPFMSG) +          
                          MSGDTA('Travail, ' *bcat &dev *bcat + 
                          'démarré') MSGTYPE(*comp)                              
endpgm                                                                

Le CLP cible

pgm  (&dev &user)                                                
/*----------------------------------------------------------*/   
/* Ce programme réinitiliase  un mot  de passe              */   
/* Peut être envoyé sur un écran remote qui est sur la      */   
/* Mire                                                     */   
/*----------------------------------------------------------*/   
dcl &dev *char 10                                                
dclf initpwdr                                                    
monmsg cpf0000 exec(goto erreur)                                 
/* controles fait dans le programme appelant */                  
             OVRDSPF    FILE(INITPWDR) DEV(&DEV) OVRSCOPE(*JOB)  
          chgvar &pwd     'ici mot de passe'                     
             dountil &in03                                       
             SNDRCVF    RCDFMT(FMT01)                            
             if cond(*not &in03) then(do)                        
             if (&pwd *ne 'ici mot de passe') then(do)           
             CHGUSRPRF  USRPRF(&USER) PASSWORD(&PWD) PWDEXP(*YES)
             Chgvar &texte ('Mot de passe réinitialisé')         
             enddo                                               
             enddo                                                   
             enddo                                                   
/* fin traitement */                                                 
             DLTOVR     FILE(INITPWD) LVL(*JOB)                      
             MONMSG     MSGID(CPF0000)                               
return                                                               
erreur:                                                              
             SNDUSRMSG  MSG('Réinitialisation de mot de passe pour' +
                          *BCAT &USER *BCAT ', actuellement +        
                          impossible') MSGTYPE(*INFO)                
             MONMSG     MSGID(CPF0000)                               
endpgm                                                               

La seule spécificité est de choisir l’unité écran d’affichage, pour qu’elle soit éligible elle doit être à la mire de connexion.

La commande pour habiller

             CMD        PROMPT('Réinitialisation de PWD')           
             PARM       KWD(UNITE) TYPE(*NAME) LEN(10) MIN(1) +     
                          PROMPT('Unité écran')                     
             PARM       KWD(PROFIL) TYPE(*NAME) LEN(10) MIN(1) +    
                          PROMPT('Profil utilisateur')              

le lancement job source:

La saisie sur le job cible :

Sur un changement de mot de passe, il peut être important d’avoir un suivi ?

Bien sur, vous pouvez ajouter des contrôles …

Le job cible qui tourne en batch !

Donc pas de possibilité d’ATTN Request , et messages d’erreurs dans QSYSOPR

Remarques :

Vous pouvez choisir l’utilisateur de lancement, mais QSECOFR est interdit dans un SBMJOB
Simple mais efficace, mais difficilement généralisable, on doit avoir un OVRDBF par DSPF

Intéressant pour des demandes ponctuelles

Dans les CLP vous pouvez indiquer directement l’unité sur la commande SNDRCVF

, , , Contrôler le nombre de paramètres passés à un programme CL – %PARMS() / CEETSTA
presence_flagSortie*INTVariable de retour : 1 ou 0
arg_numEntrée*INTPosition de la variable à tester

Remarques

Le compte des paramètres pour la arg_num commence à 1
La valeur de retour est un *INT pas un *LGL

Pour plus de détails

Documentation IBM – %PARMS() : https://www.ibm.com/docs/en/i/7.5?topic=procedure-parms-built-in-function
Documentation IBM – CEETSTA : https://www.ibm.com/docs/api/v1/content/ssw_ibm_i_75/apis/CEETSTA.htm
sinus cosinus tangentes