, , , , , , , Power Week 2025 : retour à la maison !

Vous avez assisté, ou non, à la Power Week coorganisée par IBM France et Common France :

Gaia-Volubis a été très heureux de participer à cette édition, riche en annonces. Avant de reprendre une vie normale, de retourner à notre quotidien, voici le retour de nos speakers !

Damien

C’est toujours un moment particulier pour nous dans notre calendrier, et cette année n’aura pas dérogée aux autres : beaucoup de participants, d’échanges que ce soit avec des clients ou des IBMers, quelques dépannages en direct ! 3 jours intenses.

Merci aux participants à nos sessions et à leurs retours. Il est toujours appréciables de savoir que nos choix de sujets correspondent à des attentes des participants à l’évènement.
Prochain évènement de masse : le Common Europe à Lyon en juin 2026…

Florian

Trois jours intenses et passionnants pour cette édition de la Power Week 2025 !

Au-delà du programme officiel, ce sont surtout les échanges directs avec nos clients, partenaires, IBMers et l’ensemble des participants qui ont marqué l’événement. Ces discussions spontanées, souvent en marge des sessions, sont celles qui font grandir notre réseau, ouvrent des perspectives et apportent des idées concrètes pour aller plus loin.

J’ai également pu présenter COMMON France et toutes les actions que nous avons menées cette année, notamment la Battle Dev que j’ai eu le plaisir de coorganiser avec Philippe Bourgeois et Jérôme Clément. J’espère que nous pourrons organiser une 4ᵉ édition l’année prochaine !

Merci à tous d’être venus !

Julien

Merci à toutes et à tous pour ces trois journées intenses à la Power Week 2025 !

J’ai particulièrement apprécié la qualité des échanges avec nos clients, partenaires et IBMers. Ces moments informels, toujours très enrichissants, sont essentiels pour nourrir notre réseau et nos perspectives.

J’ai également été heureux de présenter deux sessions orientées sécurité et bonnes pratiques sur IBM i, des sujets au cœur des préoccupations de nombreux clients. Merci pour votre participation et vos questions !

L’événement a une nouvelle fois confirmé sa convivialité, et la troisième édition de la Battle Dev a été remarquablement organisée.

Ravi de vous avoir retrouvés en nombre, et déjà impatient de vous revoir au Common Europe à Lyon en juin 2026 !

Betty

Ces trois jours au cœur de la communauté IBM étaient d’une richesse incroyable.

Ils m’ont permis d’avoir une vue plus globale et plus synthétique de la puissance, des possibilités et de l’avenir du power et de ses applications.

Mais le futur s’écrit aussi avec la jeune génération de  programmeurs, et la présence des participants à la pépinière de cette année m’a permis de voir que la relève était assurée grâce à ces formations.

J’ai eu l’occasion de faire une première présentation qui concernait la modernisation via SQL, et je n’ai aucun doute que les équipes hybrides qui se construisent actuellement avec des jeunes et des personnes plus expérimentées sauront trouver des méthodes de travail permettant d’aller vers cette modernisation, nécessaire, et souhaitée.

Eric

3 jours intenses de rencontres, des visages connus et des nouveaux venus. 3 jours de sessions intéressantes. Toutes les personnes rassemblées ont en commun un grand intérêt, voire même une passion pour leur système favori. Une communauté IBMi toujours aussi active.

J’ai pu cette année présenter la session « Modernisation avec SQL : comment Intégrer l’existant », avec BETTY et LUCAS. Notre première session. Ce fut intense à préparer, et à présenter.

Les outils open source ont suscité mon intérêt cette année. La présentation de BOB a été très instructive, bien qu’il reste de nombreuses questions encore sans réponse.

Merci à tous pour votre énergie et votre participation!

Pierre Louis

C’est avec plaisir que comme chaque année, on retrouve la communauté IBMi, cette année pour la première fois les gens du monde Power nous ont rejoint.

On a pu assister à des présentations techniques intéressantes, beaucoup était basées sur l’IA, comme BOB , dont la présentation a été très prometteuse …

Pour ma part j’ai trouvé très intéressant le produit MANZAN qui permet de supervisé votre IBMi et qui a l’air simple et efficace.

Cette année, j’ai présenté 2 sessions en duo avec Gautier Dumas, sur le chemin de modernisation et avec Florian Gradot sur, comment donner une seconde vie à vos application 5250, merci a eux de m’avoir supporté, ce fut une expérience intéressante.

J’ai pu échangé sur des thèmes différents, avec des clients et des partenaires, ce qui est toujours enrichissant.

Merci à IBM et à Common pour cette organisation, merci à ceux qui sont venus, et l’année prochaine !

Nathanaël

3 jours très intenses pour ma part, mais très enrichissants !

Les meilleurs moments : ceux que l’on ne peut pas mettre en photo 😉

J’ai particulièrement apprécié de pouvoir échanger de façon libre et informelle avec nos clients, partenaires, IBMers et de façon plus globale toutes les personnes présentes. C’est important, c’est la construction d’un réseau, un réseau qui apporte des perspectives, des solutions.

Donc merci à vous d’être venu, nombreux, y compris dans non sessions, de poser des questions. C’est ce qui nous donne l’énergie pour les mois à venir jusqu’au prochain grand rassemblement !

Retrouvez toutes les informations

👉 Consultez le programme complet ici avec les supports de présentation https://powerweek2025.sched.com/

👉 Les sessions de Gaia-Volubis téléchargement

Vers le prochain grand rendez-vous : Common Europe Congress à Lyon

La Power Week est aussi une étape vers un autre événement majeur : le Common Europe Congress, qui se tiendra à Lyon du 14 au 17 juin prochain. Ce congrès réunira la communauté IBM i européenne autour de conférences, ateliers, et moments conviviaux. Une occasion unique de faire rayonner notre territoire et notre expertise.

C’est la première fois en France depuis 1997, une autre ère !

Common Europe – A pan-European IT Community of IBM based solutions

/par
, , , , , , , Power Week 2025 : 3 jours pour se connecter, apprendre et faire rayonner la communauté IBM i

Cela n’a pas pu vous échapper, la semaine prochaine c’est (déjà) la Power Week, événement gratuit coorganisé par IBM France et Common France :

Durant ces 3 jours dédiés au Power Systems, au stockage, au Power11, à l’IA, à l’IBM i, AIX, Linux, la modernisation … retrouvez l’ensemble des speakers, des partenaires et des clients qui font la force de notre plateforme.

Un programme riche (et international)

Pendant trois jours, les participants auront accès à des sessions animées par les meilleurs experts, venus de France, d’Allemagne, des États-Unis … Parmi eux, des IBM Champions, reconnus pour leur expertise et leur engagement auprès de la communauté, partageront leurs connaissances sur des sujets variés : modernisation, sécurité, SQL, DevOps, IA, cloud hybride, et bien plus encore.

👉 Consultez le programme complet ici https://powerweek2025.sched.com/

Un événement gratuit, ouvert à tous

La Power Week est 100 % gratuite et ouverte à tous les professionnels de l’IBM i : développeurs, architectes, DSI, chefs de projet, consultants… C’est une opportunité rare de bénéficier de contenus de qualité sans contrainte logistique ni financière.

La force de la communauté

Au-delà des conférences, la Power Week est un lieu de rencontre et d’échange. Elle permet de :

  • Réseauter avec d’autres professionnels confrontés aux mêmes enjeux
  • Confronter les points de vue, partager des bonnes pratiques
  • Découvrir les clubs utilisateurs comme Common France, qui jouent un rôle dans l’animation de la communauté en France, mais aussi au niveau Européen.

Ces moments d’échange sont essentiels pour faire évoluer les pratiques, identifier des solutions concrètes, et tisser des liens durables.

Vers le prochain grand rendez-vous : Common Europe Congress à Lyon

La Power Week est aussi une étape vers un autre événement majeur : le Common Europe Congress, qui se tiendra à Lyon du 14 au 17 juin prochain. Ce congrès réunira la communauté IBM i européenne autour de conférences, ateliers, et moments conviviaux. Une occasion unique de faire rayonner notre territoire et notre expertise.

C’est la première fois en France depuis 1997, une autre ère !

Gaia et Volubis

Retrouvez toutes les informations sur Common France : https://commonfrance.fr/

Les speakers de Gaia et Volubis sont très heureux de participer à cette célébration : échange, partage, connaissance.

En tant que sociétés liées à la formation, il est dans notre ADN de participer à ces initiatives, comme nous le faisons depuis longtemps : les Universités IBM i depuis 2011, Pause Café en physique ou en ligne, articles de blogs …

N’hésitez pas à solliciter nos speakers sur place !

/par
, Cleanup personnalisé

il existe une logiciel qui s’appelle Cleanup

Vous voyez souvent cette commande ==> STRCLNUP dans les programmes QSTRUPPGM de vos partitions

vous voyez ce travail dans qctl

Vous avez un menu de gestion

==>go cleanup

Dans l’option 2 vous pouvez choisir la durée de rétention des éléments


Voici les 4 principaux éléments :
file de messages profil (par défaut 4 jours)
file de messages écran (par défaut 7 jours)
log des travaux (par défaut 7 jours)
log du système (par défaut 30 jours)

Par défaut l’heure de planification est 22 heures, n’hésitez pas à la changer

Ce qu’on sait moins c’est que ce programme lance un autre programme pour compléter cette épuration

Il s’agit du programme QEZUSRCLNP de la bibliothèque QSYS, on parle de ménage utilisateurs

C’est un clp, vous pouvez extraire le source par la commande RTVCLSRC

Ensuite vous pouvez le customiser, par défaut, il ne fait rien.
Souvent on ajoute une épuration des spools et des récepteurs de journaux
Ce qui est facile avec les services SQL au jourd’hui

Voici un exemple complet

Dans ce programme, on utilise la commande RTVCLNUP pour extraire les paramétrages de ménage en cours.
On utilisera également les services SQL DELETE_OLD_SPOOLED_FILES et DELETE_OLD_JOURNAL_RECEIVERS pour supprimer les spools et les récepteurs

/********************************************************************/
/* */
/* Nom du programme . . . . . . . . . . . . : QEZUSRCLNP */
/* Nom de la bibliothèque . . . . . . . . . : QSYS */
/* */
/* Le programme a été sauvegardé avant modification en QEZUSRCLNS */
/* Sinon vous pouvez également mettre une bibliothèque avant QSYS */
/* */
/* Il est appelé à la fin du programme standard de cleanup */
/* il épure les récepteurs de journaux */
/* les spools utilisateurs */
/* */
/* on se base sur les informations paramétrées dans le cleanup */
/* ==>CHGCLNUP */
/********************************************************************/
PGM
/* Variable pour RTVCLNUP extraction des informations en cours */
DCL VAR(&ALWCLNUP) TYPE(*CHAR) LEN(4)
DCL VAR(&STRTIME) TYPE(*CHAR) LEN(10)
DCL VAR(&USRMSG) TYPE(*CHAR) LEN(5)
DCL VAR(&SYSMSG) TYPE(*CHAR) LEN(5)
DCL VAR(&CRITSYSMSG) TYPE(*CHAR) LEN(5)
DCL VAR(&SYSPRT) TYPE(*CHAR) LEN(5)
DCL VAR(&SYSLOG) TYPE(*CHAR) LEN(5)
DCL VAR(&JOBQ) TYPE(*CHAR) LEN(10)
DCL VAR(&BJOBQ) TYPE(*CHAR) LEN(10)
DCL VAR(&RUNPTY) TYPE(*DEC) LEN(2 0)
DCL VAR(&JRNRCVSIZ) TYPE(*DEC) LEN(10 0)
MONMSG MSGID(CPF0000) EXEC(GOTO CMDLBL(ERREUR))
/*————————————————————*/
/* Extraction des infos du cleanup */
/*————————————————————*/
QSYS/RTVCLNUP ALWCLNUP(&ALWCLNUP) +
STRTIME(&STRTIME) +
USRMSG(&USRMSG) +
SYSMSG(&SYSMSG) +
CRITSYSMSG(&CRITSYSMSG) +
SYSPRT(&SYSPRT) +
SYSLOG(&SYSLOG) +
JOBQ(&JOBQ) +
JOBQLIB(&BJOBQ) +
RUNPTY(&RUNPTY) +
JRNRCVSIZ(&JRNRCVSIZ)
QSYS/SNDPGMMSG MSGID(CPI1E91) MSGF(QCPFMSG) TOMSGQ(*SYSOPR) –
MSGTYPE(*INFO)
QSYS/MONMSG MSGID(CPF2400)
/* Epuration des spools utilisateurs de plus SYSLOG */
RUNSQL SQL(‘CALL SYSTOOLS.DELETE_OLD_SPOOLED_FILES +
( DELETE_OLDER_THAN => CURRENT DATE – ‘ +
*BCAT &SYSLOG *BCAT ‘DAYS, PREVIEW => +
 »NO »)’) COMMIT(*NONE)
monmsg sql0000 exec(do)
QSYS/SNDPGMMSG MSGID(CPF9898) MSGF(QCPFMSG) +
MSGDTA(‘Epuration des spools +
utilisateurs en erreur’) TOMSGQ(*SYSOPR) +
MSGTYPE(*INFO)
enddo
/* Epuration des journaux de plus SYSLOG */
RUNSQL SQL(‘ CALL +
SYSTOOLS.DELETE_OLD_JOURNAL_RECEIVERS( +
DELETE_OLDER_THAN => CURRENT_DATE – ‘ +
*BCAT &SYSLOG *BCAT ‘DAYS, PREVIEW => +
 »NO ») ‘) COMMIT(*NONE)
monmsg sql0000 exec(do)
QSYS/SNDPGMMSG MSGID(CPF9898) MSGF(QCPFMSG) +
MSGDTA(‘Epuration des récepteurs +
de journaux en erreur’) TOMSGQ(*SYSOPR) +
MSGTYPE(*INFO)
enddo
QSYS/SNDPGMMSG MSGID(CPI1E92) MSGF(QCPFMSG) TOMSGQ(*SYSOPR) –
MSGTYPE(*INFO)
QSYS/MONMSG MSGID(CPF2400)
RETURN
ERREUR:
QSYS/SNDPGMMSG MSGID(CPF9898) MSGF(QCPFMSG) +
MSGDTA(‘Traitement CLEANUP Spécifique en +
erreur’) TOMSGQ(*SYSOPR) MSGTYPE(*INFO)
QSYS/MONMSG MSGID(CPF0000)
QSYS/ENDPGM

Paramétrage :

Pour que votre programme soit lancé, vous avez 2 solutions :
-le mettre dans une bibliothèque avant QSYS dans partie système de la liste des bibliothèques, c’est la meilleur solution
-remplacer celui de QSYS par le votre, bien sur, faire une sauvegarde du programme avant

Remarque :
Vous pouvez mettre ce que vous voulez dans ce programme ,
exemple : épurations des fichiers IFS dans /home de plus 6 mois

Voila simple et efficace

/par
, , Query en V7R6

Query est de moins en moins utilisé sur IBMi.

Mais certain d’entre vous continuent de l’utiliser et depuis la version 7.6 l’option 1 ne fonctionne plus.

Quand vous lancez cette option rien rien ne se passe …

==>STRQRY

Pas de panique ce problème est connu chez IBM

L’apar DT435933 semble décrire ce problème : http://ibm.com/mysupport/s/defect/aCIKe000000XwKIOA0/dt435933?language=en_US

il est corrigé par la SJ05457 https://www.ibm.com/mysupport/s/fix-information/aDrgJ000000006TSAQ/fi0135164?language=en_US

Une fois la récupération et l’application de la PTF, tout fonctionne normalement

APYPTF LICPGM(5770SS1) SELECT(SJ05457)
Objet QQUDA de QSYS type *PGM rebaptisé QPZA002137.
Objet QPZR002137 de QSYS type *PGM rebaptisé QQUDA.
PTF 5770SS1-SJ05457 V7R6M0 appliquée provisoirement à bibliothèque QSYS

Conclusions:

Mais n’oubliez pas vous devez continuer à migrer vos querys vers des requêtes SQL, plus faciles à gérer

U

/par
, Génération d’un UUID

Un UUID (Universally Unique Identifier), également appelé GUID (Globally Unique Identifier), est un identifiant conçu pour être unique à l’échelle mondiale. Il est couramment utilisé dans les échanges de données via des webservices pour identifier de manière fiable des ressources.

Voici trois méthodes permettant de générer des UUID sur votre système IBM i.

1) En SQL

Depuis peu, la génération d’UUID est possible directement en SQL via la fonction scalaire GENERATE_UUID.

Nécessite :

IBM i 7.5 : SF99950 niveau 8

IBM i 7.4 : SF99704 niveau 29

2) En RPG

Il est également possible de générer un UUID en RPG en utilisant l’API MI _GENUUID. Pour obtenir le résultat au format hexadécimal, il convient de l’associer à la procédure cvthc.

**free
ctl-opt dftactgrp(*no);

dcl-s uuidHexa   char(32) inz ;
dcl-c UUID_VERSION 4;

// DS d'un UUID
dcl-ds DSUUID qualified template;
   bytesProv  uns(10)  inz(%size(DSUUID));
   bytesAvail uns(10)  inz(0);
   version    uns(3)   inz(0);
   *n         char(7)  inz(*allx'00');
   uuid       char(16) inz(*allx'00');
End-ds;
dcl-ds UUID      likeds(DSUUID) inz(*LIKEDS);

// Prototype récupération UUID
dcl-pr generUUID extProc('_GENUUID');
   dsuuid likeds(DSUUID);
End-pr;

// Conversion caractère -> hexa
dcl-pr CharToHex ExtProc('cvthc');
   hexResult    Char(65534)  Options(*VarSize);
   charInput    Char(32767)  Options(*VarSize);
   charNibbles  Int(10)  Value;
End-Pr;

dcl-pi *n ;
end-pi ;

UUID.version = UUID_VERSION;

// génération de l'UUID
generUUID(UUID);

// Conversion en hexa
CharToHex ( uuidHexa : UUID.uuid : %Size(UUID.uuid) * 2 );

dsply %concat('-':%subst(uuidHexa:1:8):%subst(uuidHexa:9:4):
      %subst(uuidHexa:13:4):%subst(uuidHexa:17:4):
      %subst(uuidHexa:21:12)) ;

*inlr = *on;

3) Opensource

Dernière proposition, utiliser la commande uuidgen.

Nécessite libuuid1

/par
, , Schéma de base données dans VSCode

Il est possible avec certains logiciels de voir le schéma relationnel de votre base de données sous forme de diagramme.

Exemple dans DBEAVER :

L’inconvénient est qu’il faut ouvrir une fenêtre supplémentaire.

Si vous travaillez dans VSCode, voici une petite astuce pour afficher un schéma de BDD.

Installation de l’extension

Tout d’abord il faut installer l’extension DBML Entity-Relationship Diagrams visualizer :

https://marketplace.visualstudio.com/items?itemName=bocovo.dbml-erd-visualizer

Si vous ne l’avez pas encore fait, installer l’extension Code For i

https://marketplace.visualstudio.com/items?itemName=HalcyonTechLtd.code-for-ibmi

Récupération et compilation

Ensuite télécharger et compiler le programme RPG / commande ci-dessous :

Sources

Compiler en remplaçant <BIBOBJ> et <BIBSRC> par votre bibliothèque :

CRTSQLRPGI OBJ(<BIBOBJ>/TODBML) SRCFILE(<BIBSRC>/QRPGLESRC) CLOSQLCSR(*ENDMOD) OPTION(*EVENTF) DBGVIEW(*SOURCE) TGTRLS(*CURRENT) RPGPPOPT(*LVL2)
CRTCMD CMD(<BIBOBJ>/TODBML) PGM(<BIBOBJ>/TODBML) SRCFILE(<BIBSRC>/QCMDSRC) ALLOW(*ALL) CURLIB(*NOCHG) PRDLIB(*NOCHG)

Ajout de l’action Code for i

Ajouter l’action dans VSCode en remplaçant <BIBOBJ>, <BIBBDD>, <PATH> par votre bibliothèque, la bibliothèque de base de données et le chemin du fichier à générer :

?<BIBOBJ>/TODBML LIB(<BIBBDD>) PATH('<PATH>')

Paramètres de la commande:

LIB : Bibliothèque de la base de données

PATH : Le chemin du fichier dbml qui sera généré

Exemple :

ps : Vous pouvez faire une action de type « fichier » avec rafraichissement de filtre.

Lancer l’action

Visualisation du diagramme

Ouvrir le fichier et cliquer sur l’icone « show diagram » en haut à droite.

A vous de jouer !

Il est intéressant de constater que la richesse du rendu semble proportionnelle à la densité des relations dans la base… une coïncidence, sans doute 🙂

/par
, , , , Analyser les certificats TLS par SQL

Si comme nous vous avez de nombreux certificats sur vos systèmes, le ménage peut s’avérer compliqué. En effet, au fur et à mesure des renouvellements, les nouveaux certificats sont installés, les nouvelles autorités également.

Mais les suppressions de certificats sont souvent remises à plus tard. Et l’on se retrouve avec un nombre importants de certificats pour lesquels il est préférable de contrôler la non utilisation avant suppression.

SQL va nous aider ici, avec le service qsys2.certificate_info (cf https://www.ibm.com/docs/en/i/7.6.0?topic=services-certificate-info-table-function) capable de nous donner la liste des certificats et leurs attributs.

qsys2.certificate_info

Permet d’obtenir facilement les principales informations sur les certificats et autorités de certification du magasin *SYSTEM :

La même vue dans DCM :

Et on remarque donc la nécessité du ménage (dans mon cas).

Premièrement, comment faire la distinction entre les certificats et les autorités de certifications ? En utilisant la colonne PRIVATE_KEY_STORAGE_LOCATION.

Autorité de certification

select CERTIFICATE_LABEL,
       VALIDITY_START,
       VALIDITY_END,
       DOMAIN_NAMES,
       SUBJECT_COMMON_NAME,
       SUBJECT_ORGANIZATION,
       ISSUER_COMMON_NAME,
       ISSUER_ORGANIZATION,
       PRIVATE_KEY_STORAGE_LOCATION 
  from table (
      qsys2.certificate_info(certificate_store_password => '*NOPWD')
    )
  where( PRIVATE_KEY_STORAGE_LOCATION <> 'SOFTWARE' or PRIVATE_KEY_STORAGE_LOCATION  is null)

Certificat

select CERTIFICATE_LABEL,
       VALIDITY_START,
       VALIDITY_END,
       DOMAIN_NAMES,
       SUBJECT_COMMON_NAME,
       SUBJECT_ORGANIZATION,
       ISSUER_COMMON_NAME,
       ISSUER_ORGANIZATION,
       PRIVATE_KEY_STORAGE_LOCATION 
  from table (
      qsys2.certificate_info(certificate_store_password => '*NOPWD')
    )
    where PRIVATE_KEY_STORAGE_LOCATION = 'SOFTWARE'

Validité

Le premier élément trivial : quels sont les certificats périmés :

select CERTIFICATE_LABEL,
       VALIDITY_START,
       VALIDITY_END,
       DOMAIN_NAMES,
       SUBJECT_COMMON_NAME,
       SUBJECT_ORGANIZATION,
       ISSUER_COMMON_NAME,
       ISSUER_ORGANIZATION,
       PRIVATE_KEY_STORAGE_LOCATION 
  from table (
      qsys2.certificate_info(certificate_store_password => '*NOPWD')
    )
  where validity_end <= current timestamp
  order by validity_end asc  ;

Lien

Les certificats sont émis (signés) par des autorités de certification, le lien entre les deux est donc un élément indispensable.

Nous pouvons donc maintenant répondre aux questions suivantes :

Pour chaque certificat client/serveur, quel est l’autorité de certification ?

Mais cela génère des doublons :

En effet, nous faisons le lien via le Common Name de l’autorité. Mais celui-ci n’est pas obligatoirement unique, et c’est bien le cas sur les autorités locales créées via les assistants de configuration IBM i.

Pour avoir un identifiant unique, il nous faut utiliser les identifiants de clés, qui elles sont distinctes :

Mais cette information est absente de la fonction table qsys2.certificate_info.

Nous donnerons une solution (pas si simple) lors d’un prochain article dédié.

Malgré tout, ce problème ne concerne « que » les certificats générés depuis une autorité locale, elle même créée via les assistants IBM i, les autorités publiques ayants des noms uniques.

Si l’on prend un certificat acheté via Gandi :

On obtient bien une information unique et exploitable.

Pour chaque autorité, quels sont les certificats émis ?

Par exemple :

Extrait du résultat :

Par extension, quelles sont les autorités inutilisées ?

Produit :

Et le ménage ?

Avec les requêtes précédentes, vous pouvez isoler les certificats et autorités périmés ou les autorités inutilisés (dans notre cas les autorités n’ayant pas généré de certificat). Et vous pouvez donc les supprimer de façon ciblée.

Attention : les autorités et certificats peuvent être utiles et utilisés en dehors des liens vus ici. Ces requêtes permettent donc d’aider à la décision, mais ce n’est pas un automatisme !

Pour aller plus loin

Nous pouvons inclure l’analyse des applications DCM : liens applications/certificats.

Et également utiliser les API RSE pour automatiser la suppression des certificats.

Et rendre nos requêtes récursives pour permettre de suivre une hiérarchie à plus d’un niveau

Voir l’idea soumise pour avoir le lien certificat -> autorité dans la vue qsys2.certificate_info : https://ibm-power-systems.ideas.ibm.com/ideas/IBMI-I-4628

/par
, , , , SQL : « dump » des enregistrements d’une table

Suite à des demandes multiples, je propose une implémentation de « DUMP » des enregistrements d’une table (plutôt d’un objet *FILE / PF-DTA, que ce soit un PF ou une table).

L’idée est d’obtenir u script SQL contenant les instructions INSERT permettant de reproduire les données dans une autre base.

A l’image de la commande mariadb-dump par exemple (https://mariadb.com/docs/server/clients-and-utilities/backup-restore-and-import-clients/mariadb-dump). C’est un moyen commun de faire des sauvegarde/restauration de la base pour ces technologies.

DMPSQL

Oui, je ne détaille pas ici le processus de mise à jour, c’est classique : téléchargement des images et clés sur ESS, PRUV pour les contrôle etc …

Le fichier SQLSAMPLE/EMPLOYEE est ici produit par :

CALL QSYS.CREATE_SQL_SAMPLE ('SQLSAMPLE')

Cette procédure vous permet de créer et recréer des bases de données à des fins d’exemple et de tests.

Contenu du fichier :

Il s’agit d’une table très classique, représentative de la plupart des données dans nos applications.

Exemple d’usage :

DMPSQL FILE(SQLSAMPLE/EMPLOYEE)
SQLSCRIPT('/home/NB/employee.sql')

Le résultat de notre commande :

Le fichier est en UTF-8 afin de permettre la gestion de l’ensemble des caractères usuels.

Le code est disponible ici : https://github.com/FrenchIBMi/Outils/tree/master/DMPSQL

Usage ?

Cela permettait de répondre à plusieurs demandes.

Premièrement, la réplication de données sans utiliser les commandes de sauvegarde/restauration. Ces dernières nécessitent des droits élevés, alors qu’ici nous ne faisons que manipuler de la donnée.

Deuxièmement, dans le cadre de traitement de journaux (initialement en vue d’une fonction de type CDC), pour permettre d’isoler un enregistrement que l’on souhaite répliquer (avec ou sans transformation) dans une autre table.

Vous trouverez certainement d’autres usages !

Limites

Le code est fourni « as is », pour démonstration.

Quelques limites d’usage actuellement

  • Types de colonnes non supportées actuellement : CLOB, BLOB, DATALINK, XML, GRAPHIC, VARGRAPHIC, {VAR}CHAR CCSID 65535
  • Pas plus de 16Mo par enregistrement
  • On ne gère pas les alias, partitions, IASP
  • 250 colonnes maximum
  • En cas de multi-membres, seul le premier membre est traité

On peut bien évidemment ajouter de nouvelles fonctionnalités !

N’hésitez pas à donner un feedback, améliorer le code

/par
, Détail sur l’adoption de droits sur les programmes

Vous connaissez les programmes en adoption de droit, ce sont des programmes qui s’exécutent avec le droit du propriétaire et non celui du job en cours.

C’est relativement clair sur les accès natifs, mais sur SQL et sur des instructions mixtes c’est pas toujours évident à comprendre

Voici un détail sur les fichiers, on peut agir sur 3 paramètres
un sur la commande de compile ou d’assemblage USRPRF()
2 qui peuvent être fixés par la commande compile ou par les options SQL
EXEC SQL
Set Option
..
UsrPrf = *USER,
DynUsrPrf = *USER,
..
;

On va donc essayer de voir les combinaisons possibles de ces 3 options

Voici notre protocole un programme sqlrpgle et une table en *exclude et la convention *SYS

**free
ctl-opt DFTACTGRP(*NO) ;
//
// CREATE TABLE GDATA/ATSTADOPT (CODE DEC (6 , 0) NOT NULL WITH
// DEFAULT, TEXT CHAR (30 ) NOT NULL WITH DEFAULT)
// droit public *exclude
//
dcl-f
ATSTADOPT
USAGE(*UPDATE:*OUTPUT) usropn
rename(ATSTADOPT:ATSTADOPF) ;
dcl-s sqldta char(100);
//
// Option SQL
//
EXEC SQL
Set Option
Naming = *Sys,
Commit = *None,
UsrPrf = *Owner, // ici
DynUsrPrf = *Owner, // ici
Datfmt = *iso,
CloSqlCsr = *EndMod;
// accès natif
// 2 instructions Lecture + Maj
open(e) atstadopt ;
if not %error() ;
read(e) atstadopt ;
if not %error() ;
dsply (%char(%status) + ‘ accès natif ok’) ;
code = 2 ;
update(e) ATSTADOPF ;
else ;
dsply (%char(%status) + ‘ accès natif ko’) ;
endif ;
else ;
dsply (%char(%status) + ‘ ouverture native ko’) ;
endif ;
//
// sql statique
//
exec sql
UPDATE ATSTADOPT SET CODE = 3 ;
if sqlcode <> 0;
dsply (%char(sqlcode) + ‘ SQL statique ko’) ;
else ;
dsply (%char(sqlcode) + ‘ SQL statique ok’) ;
endif ;
//
// sql dynamique
//
sqldta = ‘UPDATE ATSTADOPT SET CODE = 4’ ;
EXEC SQL EXECUTE IMMEDIATE :SQLDTA ;
if sqlcode <> 0;
dsply (%char(sqlcode) + ‘ SQL dynamique ko’) ;
else ;
dsply (%char(sqlcode) + ‘ SQL dynamique ok’) ;
endif ;
Return ;

Test 1

USRPRF(*user)
UsrPrf = *User,
DynUsrPrf = *User,

call atstadopt

Opération non autorisée sur fichier ATSTADOPT de *LIBL, membre, ou unité
*N.
DSPLY 1217 ouverture native ko
Non autorisé à l’objet ATSTADOPT de GDATA type *FILE.
Non autorisé à l’objet ATSTADOPT dans GDATA, de type *FILE.
DSPLY -551 SQL statique ko
Non autorisé à l’objet ATSTADOPT de GDATA type *FILE.
Non autorisé à l’objet ATSTADOPT dans GDATA, de type *FILE.
DSPLY -551 SQL dynamique ko

Test 2

USRPRF(*owner)
UsrPrf = *User,
DynUsrPrf = *User,

call atstadopt
DSPLY 0 accès natif ok
DSPLY 0 SQL statique ok
Non autorisé à l’objet ATSTADOPT de GDATA type *FILE.
Non autorisé à l’objet ATSTADOPT dans GDATA, de type *FILE.
DSPLY -551 SQL dynamique ko

Test 3

USRPRF(*owner)
UsrPrf = *OWNER,
DynUsrPrf = *OWNER,

call atstadopt
DSPLY 0 accès natif ok
DSPLY 0 SQL statique ok
DSPLY 0 SQL dynamique ok

Test 4

USRPRF(*USER)
UsrPrf = *OWNER,
DynUsrPrf = *USER,

call atstadopt
Opération non autorisée sur fichier ATSTADOPT de *LIBL, membre, ou unité
*N.
DSPLY 1217 ouverture native ko
Non autorisé à l’objet ATSTADOPT de GDATA type *FILE.
Non autorisé à l’objet ATSTADOPT dans GDATA, de type *FILE.
DSPLY -551 SQL statique ko
Non autorisé à l’objet ATSTADOPT de GDATA type *FILE.
Non autorisé à l’objet ATSTADOPT dans GDATA, de type *FILE.
DSPLY -551 SQL dynamique ko

Test 5

USRPRF(*USER)
UsrPrf = *OWNER,
DynUsrPrf = *OWNER,
call atstadopt

Opération non autorisée sur fichier ATSTADOPT de *LIBL, membre, ou unité
*N.
DSPLY 1217 ouverture native ko
Non autorisé à l’objet ATSTADOPT de GDATA type *FILE.
Non autorisé à l’objet ATSTADOPT dans GDATA, de type *FILE.
DSPLY -551 SQL statique ko
Non autorisé à l’objet ATSTADOPT de GDATA type *FILE.
Non autorisé à l’objet ATSTADOPT dans GDATA, de type *FILE.
DSPLY -551 SQL dynamique ko

Remarques

2 petites particularités sur

1) sur Usrprf SQL

*NAMING (la valeur par défaut)
Le profil utilisateur est déterminé par la convention d’appellation. S’il s’agit de la convention *SQL,
USRPRF(*OWNER) est utilisé. S’il s’agit de la convention *SYS, USRPRF(*USER) est utilisé.

2) Option SQL souvent inutile

Si vous n’êtes pas en adoption de droit sur le programme
UsrPrf et DynUsrPrf sont sans effet

Si le programme est en adoption de droit
UsrPrf = *OWNER est implicite
à l’inverse de DynUsrPrf qui doit être à *OWNER pour fonctionner

Une petite requête pour analyser une bibliothèque :

// liste des programmes avec les users d’exécution d’une bibliothèque
SELECT A.PROGRAM_SCHEMA,
a.PROGRAM_NAME,
a.PROGRAM_TYPE,
IFNULL(a.NAMING, ‘*NOSQL’) AS convention,
a.PROGRAM_OWNER,
b.user_profile AS user_program,
IFNULL(A.USER_PROFILE, ‘*NOSQL’) AS user_static,
IFNULL(A.DYNAMIC_USER_PROFILE, ‘*NOSQL’) AS usre_dynamic
FROM qsys2.sysprogramstat a
JOIN QSYS2.PROGRAM_INFO b
ON a.PROGRAM_SCHEMA = b.Program_library
AND a.PROGRAM_NAME = b.PROGRAM_NAME
where A.PROGRAM_SCHEMA = ‘votre bib’;

/par