accéder à la publication Sylvain Guilbaud · Juin 5 L'utilisation de multiples namespaces n'induit pas de surconsommation mémoire directe, mais une mauvaise gestion des mappings ou une configuration sous-optimale des caches peut dégrader les performances. Une planification attentive des accès aux données et des paramètres système adaptés (cache global, $ZSTORAGE, huge pages) permet de maintenir une empreinte mémoire efficace. 1. Mécanisme des namespaces et bases de données Un namespace est une entité logique sans surcoût mémoire intrinsèque. Chaque namespace accède à des bases de données (fichiers IRIS.DAT) via des mappings prédéfinis ou personnalisés. La consommation mémoire dépend principalement : Du cache des globals (mémoire partagée pour les données) Du cache des routines (mémoire partagée pour le code) De la configuration des processus individuels ($ZSTORAGE). 2. Impact des accès multi-bases Accès concurrents à plusieurs bases : Augmente l'utilisation du cache global si les données sont dispersées. Peut entraîner une fragmentation mémoire si les allocations/désallocations sont fréquentes. Mapping intelligent : Des mappings permettent d'optimiser l'accès aux données sans dupliquer les buffers, en partageant des données de référence ou du code entre plusieurs namespaces. 3. Optimisations recommandées Configuration du cache global : Allouer 25-30% de la RAM disponible pour les buffers 8KB (valeur par défaut). Utiliser des huge pages Linux pour réduire la surcharge mémoire. Limite par processus : Ajuster Maximum Per-Process Memory (KB) via le portal (256KB à 2TB). Surveiller les erreurs <STORE> pour détecter les besoins d'ajustement. Stratégie de déploiement : Regrouper les données fréquemment accédées dans une même base ou définir un mapping dans %ALL pour donner un accès à tous les namespaces aux données fréquentes. Utiliser des bases temporaires distinctes pour les opérations transactionnelles lourdes. 4. Comparaison avec les bases en mémoire InterSystems IRIS évite les écueils des bases purement en mémoire : Gestion dynamique : Seules les données actives sont conservées en mémoire via un mécanisme de buffer pool. Persistance native : Élimine le besoin de recharger les données après un redémarrage. Benchmarks : IRIS est très souvent plus rapide en requêtes SQL que des solutions in-memory pures.
accéder à la publication Sylvain Guilbaud · Juin 4 @Corentin Blondeau, c'est la nature des 20 flux qui doit être considérée pour décider du nombre de namespaces. Si les 20 flux sont tous liés entre eux d'un point de vue métier, un seul namespace est recommandé. Si parmi ces 20 flux, une vraie séparation métier existe, il est recommandé de les séparer dans plusieurs namespaces, même si certains d'entre eux ne reçoivent qu'un flux, la séparation offrira plus de souplesse dans l'administration et la gestion opérationnelle. L'impact sur la consommation mémoire est marginal ; seuls les processus Ens.Actor, Ens.Alarm, Ens.Alert, Ens.MonitorService, Ens.ProductionMonitorService, Ens.ScheduleHandler seront dupliqués pour chaque nouveau namespace. Chaque instance IRIS pouvant supporter jusqu'à 2048 namespaces, il ne faut pas s'en priver dès l'instant où le bénéfice de l'isolation est au rendez-vous 😉
accéder à la publication Sylvain Guilbaud · Juin 4 Dans InterSystems IRIS, le choix entre un seul namespace ou plusieurs dépend des besoins en isolation, sécurité, gestion du code et performances. Si tous les flux sont homogènes d'un point de vue métier, il n'est pas nécessaire de recourir à plusieurs namespaces (plusieurs client utilisent en production des centaines ou des milliers de flux dans un seul namespace). L'utilisation de plusieurs namespaces offre cependant plusieurs avantages, notamment liés à la sécurité et à l'isolation des processus et données, dès l'instant où vous avez des flux répondant à des besoins métiers hétérogènes ou à des utilisations spécifiques. Avantages d'utiliser plusieurs namespaces Isolation des environnements Chaque namespace peut être dédié à un usage spécifique (développement, test, production). Cela réduit les risques de conflits entre configurations. Sécurité renforcée Les mappings contrôlent précisément l'accès aux données et au code. Un namespace peut restreindre l'accès à certaines bases de données via des règles de mapping global/routine. Gestion modulaire Configuration indépendante pour chaque flux d'intégration (interopérabilité) Mise à jour/redéploiement partiel sans impacter l'ensemble du système Inconvénients de multiples namespaces Complexité accrue de l’administration Plus il y a de namespaces, plus la gestion des mappings, des bases de données associées, des configurations de sécurité, des accès utilisateurs et des stratégies de sauvegarde devient complexe. Chaque namespace nécessite une configuration propre (databases, mappings, sécurité), ce qui multiplie les tâches d’administration et augmente le risque d’erreurs humaines lors des modifications ou migrations. Gestion des sauvegardes et restaurations La multiplication des namespaces entraîne une augmentation du nombre de fichiers IRIS.DAT à sauvegarder et restaurer. Cela peut rallonger les temps de sauvegarde/restauration et compliquer la gestion des versions et des points de reprise, car il faut garantir la cohérence entre plusieurs bases de données et namespaces. Verrouillage et contention Les locks sur les globals sont globaux à la base de données : si plusieurs namespaces accèdent à la même base de données via des mappings, ils peuvent se retrouver en concurrence sur les mêmes verrous, ce qui peut générer des contentions inattendues et compliquer le diagnostic des problèmes. Mise à jour et déploiement Mettre à jour du code ou des configurations dans plusieurs namespaces nécessite de répéter les opérations, ce qui augmente le risque d’incohérences entre environnements et la charge de travail pour les équipes DevOps. Surcoût de maintenance Chaque namespace ajoute des tâches de maintenance (monitoring, logs, gestion des utilisateurs, etc.). À grande échelle, cela peut devenir difficile à suivre et à automatiser sans outils adaptés Difficulté de suivre une trace complète dans Visual Trace : un inconvénient majeur de l’utilisation de plusieurs namespaces, lorsque les flux métier sont liés. Visual Trace ne permet de visualiser que les messages et les transactions d’un seul namespace à la fois. Si un flux métier traverse plusieurs productions réparties sur différents namespaces, il n’est pas possible de visualiser le parcours global du message ou de la transaction dans une seule vue Visual Trace. L’opérateur ou le développeur doit ouvrir séparément chaque namespace dans le Management Portal, puis rechercher manuellement les messages correspondants (souvent avec des identifiants différents ou des métadonnées partielles), ce qui rend le diagnostic et l’analyse chronologique beaucoup plus complexes. Il n’existe pas de corrélation automatique des traces entre namespaces : chaque Visual Trace est limité à l’espace de noms courant, sans suivi transversal natif. Dès lors que des flux d’intégration sont distribués sur plusieurs namespaces, la traçabilité globale via Visual Trace devient morcelée, ce qui complique considérablement le support, la maintenance et l’investigation des incidents métier. Isolation des processus L’isolation des processus dans chaque espace de noms (namespace) InterSystems IRIS est un sujet important pour la sécurité, la stabilité et la gestion de vos applications. Voici une explication détaillée : 1. Qu’est-ce qu’un namespace dans IRIS ? Un namespace est un environnement logique qui regroupe : Une ou plusieurs bases de données (globals, routines) Des mappings de code et de données Des configurations spécifiques (services, productions, etc.) 2. Isolation des processus : ce qui est isolé a. Espace d’adressage des données Chaque namespace a ses propres mappings de bases de données. Les globals et routines sont isolés par défaut : un processus dans le namespace A n’accède pas aux données du namespace B (sauf si mapping explicite). b. Contexte d’exécution Les processus lancés dans un namespace (par exemple, un job d’intégration, une session terminal, un service REST) s’exécutent dans le contexte de ce namespace. Les variables système, le $namespace courant, et les paramètres de session sont propres à chaque processus et à chaque namespace. c. Productions d’interopérabilité Les productions (Ensemble/IRIS Interoperability) sont isolées par namespace : chaque namespace a sa propre production, ses propres Business Services, Processes et Operations. Les queues, logs, et messages sont séparés. d. Sécurité Les droits d’accès (Rôle, Ressource) peuvent être définis par namespace. Les utilisateurs peuvent être limités à certains namespaces via la configuration des applications web/services. 3. Ce qui n’est PAS isolé Processus système : Les processus système (ex : le démon d’écriture, le garbage collector) sont globaux à l’instance IRIS. Caches partagés : Le cache de routines et de données est partagé entre tous les namespaces. Mémoire partagée (gmheap) : Les structures internes sont communes. Journalisation (Write Image Journal, Journaux d’audit) : Certains fichiers de journalisation sont globaux. 4. Exemple pratique Si vous lancez un job dans le namespace A, il ne voit que les données et le code de A (sauf mapping). Si un processus dans le namespace B plante, il n’impacte pas directement les jobs du namespace A. Les productions d’interopérabilité ne partagent pas leurs queues ou messages. 5. Limites de l’isolation Processus : Tous les processus sont visibles dans la vue système (^%SS, Management Portal), quel que soit leur namespace d’origine. Ressources système : Les processus de tous les namespaces consomment la même mémoire, CPU et I/O disque. 6. Résumé Élément Isolé par namespace Global à l’instance Données (globals) ✔️ Code (routines/classes) ✔️ Productions interop ✔️ Processus système ✔️ Caches (données/routines) ✔️ Mémoire partagée ✔️ Journalisation ✔️ L’isolation des processus dans chaque namespace est forte sur le plan applicatif (données, code, productions), mais partielle sur le plan système (ressources partagées). Pour une isolation maximale, il faut combiner la séparation par namespace avec des politiques de sécurité et, si nécessaire, des instances IRIS séparées. En conclusion, une architecture multi-namespaces est préférable pour des flux hétérogènes nécessitant une isolation forte, malgré une complexité opérationnelle accrue. Pour des flux homogènes, un namespace unique avec scaling vertical (CPU/mémoire) peut suffire.
accéder à la publication Sylvain Guilbaud · Mai 30 Bonjour Cécile, L'erreur "BP completion cleanup error deleting BP instance" dans InterSystems IRIS survient généralement lors de la suppression d'une instance de Business Process (BP) après son exécution.Si le BP est configuré avec PoolSize=0, l'action de suppression des instances peut échouer car le système ne peut pas contrôler tous les threads simultanés. As-tu plus d'informations dans l'Event Log : Interoperability > Event Log ?
accéder à la publication Sylvain Guilbaud · Juil 9, 2024 Bonjour Moussa, le messages.log indique une version IRIS 2023.1 : Si tu utilises ARG IMAGE=intersystemsdc/irishealth-community tu obtiendras une version 2024.1 NB : pour récupérer régulièrement les images plus récentes, le repository officiel InterSystems est https://containers.intersystems.com/contents Les noms des différentes images régulièrement mises-à-jour sont : EXTENDED_MAINTENANCE=latest-em CONTINUOUS_DELIVERY=latest-cd DEVELOPER_PREVIEW=latest-preview IMAGE_IRIS_EM=containers.intersystems.com/intersystems/irishealth-community:$EXTENDED_MAINTENANCE IMAGE_IRIS_CD=containers.intersystems.com/intersystems/irishealth-community:$CONTINUOUS_DELIVERY IMAGE_IRIS_PREVIEW=containers.intersystems.com/intersystems/irishealth-community:$DEVELOPER_PREVIEW Tu peux utiliser ce repo pour tester les différentes versions d'IRIS for Health : https://github.com/SylvainGuilbaud/IRISHealth_community
accéder à la publication Sylvain Guilbaud · Juin 6, 2024 Bonjour @Julia Pertin pour tester un objet dynamique vide tu peux utiliser la méthode d'instance %Size() qui renverra 0 IRISAPP>set monobjet={} IRISAPP>write monobjet.%Size() 0 IRISAPP>zw monobjet monobjet={} ; <DYNAMIC OBJECT> IRISAPP>set monobjet.data="une valeur" IRISAPP>write monobjet.%Size() 1 IRISAPP>zw monobjet monobjet={"data":"une valeur"} ; <DYNAMIC OBJECT>
accéder à la publication Sylvain Guilbaud · Avr 25, 2024 Simplement en utilisant l'option Resource dans une instruction CreateDatabase de la section [Actions] du fichier merge.cpf : [Actions] CreateResource:Name=%DB_IRISAPP_DATA,Description="IRISAPP_DATA database" CreateDatabase:Name=IRISAPP_DATA,Directory=/usr/irissys/mgr/IRISAPP_DATA,Resource=%DB_IRISAPP_DATA CreateResource:Name=%DB_IRISAPP_CODE,Description="IRISAPP_CODE database" CreateDatabase:Name=IRISAPP_CODE,Directory=/usr/irissys/mgr/IRISAPP_CODE,Resource=%DB_IRISAPP_CODE CreateNamespace:Name=IRISAPP,Globals=IRISAPP_DATA,Routines=IRISAPP_CODE,Interop=1
accéder à la publication Sylvain Guilbaud · Jan 25, 2024 Bonjour @Jean-Charles Cano si ton service FTP ne doit s'exécuter qu'une seule fois par jour, à une heure bien précise, la planification est effectivement le bon moyen, en veillant à ce que l'intervalle entre appel soit supérieur à la durée séparant l'heure du START et celle du STOP. L'autre moyen, sans planification, est de simplement mettre un intervalle entre appels de 86400 pour obtenir un appel une seule fois par jour. L'inconvénient ici étant que le service restera démarré 24h/24h sans utilité.
accéder à la publication Sylvain Guilbaud · Jan 15, 2024 Bonjour @Cyril Grosjean essaie d'utiliser embedded python, en remplaçant la connexion par create_engine('iris+emb:///'): from sqlalchemy import create_engine _engine = create_engine('iris+emb:///')
accéder à la publication Sylvain Guilbaud · Jan 15, 2024 Bonjour @Cyril Grosjean essaie d'utiliser embedded python, en remplaçant la connexion par create_engine('iris+emb:///'): from sqlalchemy import create_engine _engine = create_engine('iris+emb:///')
accéder à la publication Sylvain Guilbaud · Jan 12, 2024 Bonjour @Pierre LaFay pour rediriger la sortie standard du Terminal IRIS, tu peux ouvrir un fichier et l'indiquer via la commande USE Exemple ci-dessous et en ligne : Class utils.file { Parameter DIRECTORY = "/data/"; Parameter FILENAME = "results"; Parameter EXTENSION = ".txt"; /// Redirect standard output to a file ClassMethod results() As %Status { set sc = $$$OK SET file=..#DIRECTORY _ ..#FILENAME _ "_" _ $tr($zdt($h,8)," :")_..#EXTENSION OPEN file:("NRW"):5 USE file WRITE !,"BEGIN RESULTS ",$zdt($h,3),! do ##class(UnitTest.utils).run("Test3") WRITE !,"END RESULTS ",$zdt($h,3) CLOSE file WRITE !,"Results are in ",file,! return sc } } Avec le fichier contenant toutes les écritures vers la sortie :
accéder à la publication Sylvain Guilbaud · Jan 5, 2024 Réponse d' @Eduard Lebedyuk : L'approche la plus sûre consiste à utiliser Privileged Routine Application.
accéder à la publication Sylvain Guilbaud · Déc 27, 2023 Une fois obtenu le fichier Excel, il est possible de le convertir en CSV puis en PDF en utilisant les librairies pandas et csv2pdf ClassMethod toPDF(file As %String) As %Status [ Language = python ] { import pandas as pd from csv2pdf import convert PATH = '/home/irisowner/dev/data/' PATH_TO_XLSX = PATH+file+'.xlsx' PATH_TO_CSV = PATH+file+'.csv' PATH_TO_PDF = PATH+file+'.pdf' read_file = pd.read_excel (PATH_TO_XLSX) read_file.to_csv (PATH_TO_CSV, index = None, header=True) convert(PATH_TO_CSV , PATH_TO_PDF) }
accéder à la publication Sylvain Guilbaud · Déc 27, 2023 Bonjour @Pierre LaFay en m'inspirant des liens proposés par @Guillaume Rongier tu trouveras ci-dessous et en ligne un exemple de génération de feuille Excel à partir de openpyxl Code /// d ##class(apptools.python.xlsx).test() Class apptools.python.xlsx { Parameter DATADIRECTORY = "/home/irisowner/dev/data/"; /// d ##class(apptools.python.xlsx).test() ClassMethod test(name As %String = "titanicTest") As %Status { set name=name_$INCREMENT(^RunAppTest(name)) set sql="select * FROM dc_demo.titanic" #; set sql="select name,sex,age FROM dc_demo.titanic" set gn="^||tmp",format=",n,n,n,n,s5,s5,s40,s5,s50" set format("freeze")="B3" ;freeze set format("title")="Title "_sql set format("sheetname")="test" #; do ##class(apptools.core.sys).SaveSQL(sql,gn) set exec="##class(apptools.python.xlsx).MarkRed(.%AppLogInfoVal, .%AppLogInfoCol, .%AppLogInfoHead, .%AppLogInfoTemp)" #; do ##class(apptools.python.xlsx).gn2xlsx(gn,.format,..#DATADIRECTORY_"___gn2xlsx*.xlsx","Title "_sql,,,,exec) set format("freeze")="B4" ;freeze do ##class(apptools.python.xlsx).sql2xlsx(sql,.format,..#DATADIRECTORY_name_".xlsx") do ..toPDF(name) return $$$OK } ClassMethod sql2xlsx(sql, format = "", file As %String = "/home/irisowner/dev/data/sample-py-*.xlsx", title = "") { set st=$$$OK set statement = ##CLASS(%SQL.Statement).%New() set status=statement.%Prepare(sql) if $$$ISERR(status) {write "%Prepare failed:" do $SYSTEM.Status.DisplayError(status) quit} set rset=statement.%Execute() if (rset.%SQLCODE '= 0) {write "%Execute failed:", !, "SQLCODE ", rset.%SQLCODE, ": ", rset.%Message quit} ;prepare XLSX try { set openpyxl = ##class(%SYS.Python).Import("openpyxl") } catch err { do ..InstallPy("openpyxl") set openpyxl = ##class(%SYS.Python).Import("openpyxl") } set wb = openpyxl.Workbook() #; grab the active worksheet set ws = wb.active set ws.title = $select($D(format("sheetname"),ds):ds,1:"sheetname") set pybuiltins = $system.Python.Import("builtins") set pycols = pybuiltins.list() do pycols.append(" ") do ws.append(pycols) set pycols = pybuiltins.list() set (count)=0 set ColCount=statement.%Metadata.columns.Count() for i=1:1:ColCount { do pycols.append(statement.%Metadata.columns.GetAt(i).colName) set col=openpyxl.utils."get_column_letter"(i) } do ws.append(pycols) while (rset.%Next()) { set count=count+1 set pyrows = pybuiltins.list() for ii=1:1:ColCount { set val=..CleanCtrl(rset.%GetData(ii)) if $e($P(format,",",ii),1)="d" { //date set val=..ToPyDate(val) } elseif $e($P(format,",",ii),1,2)="dt" { //datetime set val=..ToPyDateTime(val) } elseif $e($P(format,",",ii),1)="n" { //number set val=+val } do pyrows.append(val) } do ws.append(pyrows) } ;} if $g(format("freeze"))'="" { ; set builtins = $system.Python.Import("builtins") zwrite builtins.type(ws) zwrite builtins.dir(wb) set ws."freeze_panes" = pybuiltins.str(format("freeze")) ;format("freeze") ;set ws."freeze_panes" = "B2" ;format("freeze") } else { set ws."freeze_panes" = pybuiltins.str("B2") ;default } if file["*" set file=$replace(file,"*","-"_$zd($h,3)_"_"_$tr($zt($p($h,",",2),1),":")) write !,"Save into "_file_" rows: "_count do wb.save(file) return $GET(count) } ClassMethod toPDF(file As %String) As %Status [ Language = python ] { import pandas as pd from csv2pdf import convert PATH = '/home/irisowner/dev/data/' PATH_TO_XLSX = PATH+file+'.xlsx' PATH_TO_CSV = PATH+file+'.csv' PATH_TO_PDF = PATH+file+'.pdf' read_file = pd.read_excel (PATH_TO_XLSX) read_file.to_csv (PATH_TO_CSV, index = None, header=True) convert(PATH_TO_CSV , PATH_TO_PDF) } /// set gn="^||tmp",format="n,s150,,,,,,,,d," /// set format("freeze")="B5" ;freeze /// d ##class(apptools.core.sys).SaveSQL("select * from apptools_core.Log order by id desc",gn) /// d ##class(apptools.python.xlsx).gn2xlsx(gn,.format,"/iris-backup/temp/test*.xlsx","Test") /// Example coloring a column values if is not null /// set exec="##class(apptools.python.xlsx).MarkRed(.%AppLogInfoVal, %AppLogInfoCol, %AppLogInfoHead, .%AppLogInfoTemp)" ClassMethod MarkRed(Val, Col, Head, openpyxl) { s res=Val if $g(Head) { if res.value="DispatchClass" set Col("DispatchClass",Col)="" } else { if $Data(Col("DispatchClass",Col)) { if res.value'="" { ;set argsfill = {"start_color":"D3D3D3", "end_color":"D3D3D3", "fill_type":"solid"} ;set fill = openpyxl.styles.PatternFill(argsfill...) set argsfont = {"color":"DC143C", "bold":true, "italic":false, "size":11} ;color Crimson set font = openpyxl.styles.Font(argsfont...) ;set res.value=$FN(res.value,"",2) ;set res.fill=fill set res.font=font } } } q res } /// do ##class(apptools.python.xlsx).InstallPy("openpyxl") ClassMethod InstallPy(lib) { // depricated ;set sc = ##class(%SYS.Python).Install("openpyxl") set cmd="pip3 install --target /usr/irissys/mgr/python/ "_lib if $zversion(1)'=3 { set tMgrDir = $System.Util.ManagerDirectory() set tBinDir = $System.Util.BinaryDirectory()_"irispip.exe" set cmd=tBinDir_" install --target "_tMgrDir_"python "_lib } set st=##class(%ZPM.PackageManager.Developer.Utils).RunCommandViaZF(cmd,.tLog,.tErr) quit $$$OK } /// Date YYYY-MM-DD HH:MM:SS to Python dt.datetime ClassMethod ToPyDateTime(val, ByRef dt) { quit:'val val if val["." set val=$p(val,".",3)_"-"_$p(val,".",2)_"-"_$p(val,".",1) // format YYYY-MM-DD if val'["-" set val=$zd(+val,3) // $h format set dt = ##class(%SYS.Python).Import("datetime") set val=dt.datetime(+$p(val,"-",1), +$p(val,"-",2), +$p($p(val,"-",3)," "),+$p($p(val,":",1)," ",2),+$p($p(val,":",2)," ",2),+$p($p(val,":",3)," ",2)) quit val } /// Date YYYY-MM-DD to Python dt.date ClassMethod ToPyDate(val, ByRef dt) { quit:'val val if val["." set val=$p(val,".",3)_"-"_$p(val,".",2)_"-"_$p(val,".",1) // format YYYY-MM-DD if val'["-" w 111_val_111 set val=$zd(+val,3) // $h format set dt = ##class(%SYS.Python).Import("datetime") set val=dt.date(+$p(val,"-",1), +$p(val,"-",2), +$p($p(val,"-",3)," ")) quit val } ClassMethod CleanCtrl(val) { quit $zstrip(val,"*C") } }
accéder à la publication Sylvain Guilbaud · Sept 26, 2023 Réponse de @Ashok Kumar T Bonjour @Muhammad Waseem Vous pouvez peut-être essayer d'extraire la ressource patient du bundle ou l'utiliser si c'est déjà une ressource. Chargez la classe du modèle patient FHIR HS.FHIR.DTL.vR4.Model.Resource.Patient avec la ressource extraite. Ensuite, vous pouvez convertir la date de naissance et valider l'âge. Vous pouvez utiliser la même logique dans votre code DTL dans un processus FHIR entre le service FHIR (HS.FHIRServer.Interop.Service) et l'opération FHIR (HS.FHIRServer.Interop.Operation). ClassMethod VaidatePatientResource(patientResourceStreram As %Stream.Object) { #dim patient As HS.FHIR.DTL.vR4.Model.Resource.Patient try { set patient = ##class(HS.FHIR.DTL.vR4.Model.Resource.Patient).FromJSON(patientResourceStreram) Set age = $horolog - $ZdateH(patient.birthDate,3)\360 if age<18 $$$ThrowStatus($$$ERROR($$$GeneralError, "Age is less than 18")) } catch ex { w ex.DisplayString() } }
accéder à la publication Sylvain Guilbaud · Sept 20, 2023 Bonjour @Julia Pertin, si j'ai bien compris ton besoin, pour régler ton problème qui consiste à éviter de récupérer plusieurs fois le même flux json, ton Business Service doit servir uniquement à appeler un Business Process, qui lui va se charger de récupérer le flux json pour le passer à une Business Operation. Dans le cas où ton Business Service appelle le Business Process de manière synchrone, il attendra bien la réponse avant de s'exécuter à nouveau.Dans le cas contraire, c'est à dire si le Business Process est appelé de manière asynchrone, le Business Service fera un nouvel appel à chaque atteinte du temps prévu par le paramètre "INTERVALLE ENTRE APPELS".
accéder à la publication Sylvain Guilbaud · Sept 15, 2023 Réponse de @Dmitry Maslennikov Pour quelques versions déjà, Caché et IRIS prennent déjà en charge OAuth2 dès le départ. Regardez la documentation. Cela dépend de votre architecture, vous pouvez utiliser cette méthode ou utiliser n'importe quel fournisseur d'identité externe comme keycloack. Et je pense qu'IAM peut également vous aider.
accéder à la publication Sylvain Guilbaud · Sept 15, 2023 Réponse de @Rob Tweed Nous avons deux produits Open Source qui prendront en charge les JWT pour vous de la manière correspondant à ce que vous demandez (c'est-à-dire les services REST avec IRIS) : - QEWD, si vous souhaitez tout implémenter en back-end dans Node.js / JavaScript - mgweb-server si vous souhaitez utiliser la logique ObjectScript pour votre logique back-end Pour QEWD et IRIS, voir : https://github.com/robtweed/qewd-starter-kit-iris-networked En particulier pour les services REST, voir : https://github.com/robtweed/qewd-starter-kit-iris-networked/blob/master/... et plus précisément cette section: https://github.com/robtweed/qewd-starter-kit-iris-networked/blob/master/... Pour le serveur mgweb, voir : https://github.com/robtweed/mgweb-server spécifiquement utilisé avec IRIS : https://github.com/robtweed/mgweb-server/blob/master/IRIS.md et dans ce document, cette section sur les JWT : https://github.com/robtweed/mgweb-server/blob/master/IRIS.md#using-json-... Rob
accéder à la publication Sylvain Guilbaud · Sept 12, 2023 @Luis Angel Pérez Ramos propose une autre solution, hors Embedded Python : Eh bien, si votre instance IRIS ne prend pas en charge Embedded Python, vous pouvez procéder comme suit (si vous utilisez un serveur Linux) : Installez une application comme ImageMagick sur votre serveur À partir de votre opération commerciale, utilisez la fonction $ZF(-100) pour exécuter sur le serveur la commande magique permettant de convertir le PDG en JPG, quelque chose comme : $ZF(-100,"","magick","\usr\image.pdf","\usr\image.jpg") Peut-être que cela prend un certain temps, vous pouvez attendre la fin de l'exécution ou simplement créer un service métier pour obtenir tous les nouveaux fichiers PDF.
