.png)
InterSystems IRIS for Health™ est la première et la seule plateforme de données au monde conçue spécifiquement pour le développement rapide d'applications de santé afin de gérer les données les plus critiques du monde. Elle comprend de puissantes fonctionnalités prêtes à l'emploi : traitement et analyse des transactions, modèle de données de santé extensible, développement de solutions basé sur FHIR, prise en charge des normes d'interopérabilité de santé, etc. Toutes ces fonctionnalités permettent aux développeurs de créer rapidement de la valeur et des applications révolutionnaires. En savoir plus.
Bonjour,
J'essaye d'importer une application web que j'ai créé en local sur le serveur de prod, cependant je ne trouve pas le moyen d'exporter sous forme de fichier l'application web et de l'importer par la suite. Quelqu'un aurait-il une idée ?
Merci d'avance !
Cette publication soutient la démonstration au Global Summit 2023 "Demos and Drinks" avec des détails très probablement perdus dans le bruit de l'événement. Il s'agit d'une démonstration sur la façon dont on peut utiliser les capacités FHIR SQL d'InterSystems du Serveur FHIR avec la solution Super Awesome Identity and Resolution, Zingg.ai pour détecter les enregistrements en double dans votre référentiel FHIR, et l'idée de base derrière la remédiation de ces ressources avec le PID^TOO|| en cours de construction actuellement inscrit dans le programme Incubateur d'InterSystems. Si vous êtes dans
InterSystems Reports version 23.2 est désormais disponible sur le site InterSystems Software Distribution dans la section Components. Ils sont intitulés InterSystems Reports Designer et InterSystems Reports Server et sont disponibles pour Mac OSX, Windows ou Linux. insightsoftware a choisi de passer d'un plan de numérotation numérique à un plan de numérotation annuel en 2023, il n'y a donc pas de versions 20 à 22 ; les versions augmentent de la version 19 à la version 23. Notez que l'image Docker du serveur de rapports sera disponible ultérieurement à partir du référentiel de conteneurs.
Bonjour la Communauté,
pour se former rapidement et en totale autonomie sur IRIS, je vous propose quelques liens qui pourront vous aider dans cette belle promenade riche en découvertes :
Salut la communauté
J'ai créé un service métier créé à partir de "HS.FHIRServer.Interop.Service" dans la production FHIR.
Je souhaite valider la ressource Patient de FHIR selon laquelle l'âge doit être supérieur à 18 ans.
Comment puis-je y parvenir à partir d'objectscript ainsi qu'à partir de DTL ?
Merci
Salut la Communauté,
Il est temps d'annoncer les gagnants du concours de développement Python InterSystems 2023 !
Merci à tous nos incroyables participants qui ont soumis 15 applications 🔥
%20(3).jpg)
.png)
FHIR a transformé le secteur des soins de santé en fournissant un modèle de données normalisé pour la création d'applications de soins de santé et en favorisant l'échange de données entre les différents systèmes de soins de santé. La norme FHIR est basée sur des approches modernes axées sur les API, ce qui la rend plus accessible aux développeurs mobiles et web. Cependant, l'interaction avec les API FHIR peut encore s'avérer difficile, en particulier lorsqu'il s'agit de requêter des données à l'aide du langage naturel.
Nous présentons l'application Chaîne OpenAPI et IA - FHIR une solution qui permet aux utilisateurs d'interagir avec les API FHIR à l'aide de requêtes en langage naturel. Conçue avec OpenAI, LangChain et Streamlit, cette application simplifie le processus d'interrogation des API FHIR et le rend plus facile à utiliser.
Les spécifications OpenAPI (anciennement connues sous le nom de "Swagger" et faisant actuellement partie de l'" Initiative OpenAPI " (https://www.openapis.org/)) sont devenues un outil essentiel dans le monde du développement logiciel, permettant aux développeurs de concevoir, de documenter et d'interagir avec les API de manière plus efficace. Les spécifications OpenAPI définissent un format normalisé, lisible par une machine, pour décrire les API RESTful, offrant ainsi un moyen clair et cohérent de comprendre leurs capacités et de les utiliser de manière efficace.
Dans le domaine des soins de santé, FHIR s'est imposé comme une norme de premier plan pour l'échange de données et l'interopérabilité. Pour améliorer les capacités d'interopérabilité de FHIR, HL7 a officiellement documenté les spécifications OpenAPI de FHIR, qui permettent aux développeurs d'intégrer de manière transparente les ressources et les opérations FHIR dans leurs solutions logicielles.
L'application Chaîne OpenAPI et IA - FHIR s'appuie sur LangChain pour charger et analyser les spécifications OpenAPI (Chaîne OpenAPI). Ensuite, sur la base de ces spécifications, la chaîne d'invites fournies par OpenAI vise à comprendre les requêtes en langage naturel et à les convertir en demandes d'API FHIR appropriées. Les utilisateurs peuvent poser des questions en langage naturel et l'application interagira avec l'API FHIR choisie pour récupérer les informations pertinentes.
Par exemple, un utilisateur peut demander : "Quelle est la dernière mesure de la tension artérielle du patient John Doe (ID 111) ?" L'application traduira alors cette requête en une demande d'API FHIR, récupérera les données requises et les présentera à l'utilisateur dans un format facilement compréhensible.
Pour commencer à utiliser l'application Chaîne OpenAPI et IA - FHIR, suivez les étapes suivantes :
Grâce à l'intégration de capacités d'IA et de traitement du langage naturel, l'application haîne OpenAPI et IA - FHIR offre un moyen plus intuitif pour interagir avec les API FHIR, rendant les données de santé plus accessibles et plus faciles à analyser pour les utilisateurs de tous niveaux techniques.
Votez pour notre application dans le cadre du concours Grand Prix si vous la trouvez pertinente !
Si vous pensez à des applications qui pourraient utiliser cette implémentation, n'hésitez pas à les partager dans le fil de discussion.
Avec le Serveur InterSystems IRIS FHIR, vous pouvez construire une stratégie pour personnaliser le comportement du serveur (pour plus de détails, consultez documentation).
Ce référentiel contient une stratégie Python qui peut être utilisée comme point de départ pour construire votre propre stratégie en Python.
Cette stratégie de démonstration présente les caractéristiques suivantes :
Account (compte).Observation.
Observation est renvoyée.Observation n'est pas renvoyée.git clone git@github.com:grongierisc/iris-fhir-python-strategy.git
docker-compose build
docker-compose up -d
GET http://localhost:8083/fhir/r4/metadata
Accept: application/json+fhir
La ressource Account (compte) ne peut pas figurer dans la Déclaration de capacité.
GET http://localhost:8083/fhir/r4/Account
Accept: application/json+fhir
retours :
{
"resourceType": "OperationOutcome",
"issue": [
{
"severity": "error",
"code": "not-supported",
"diagnostics": "<HSFHIRErr>ResourceNotSupported",
"details": {
"text": "Resource type 'Account' is not supported."
}
}
]
}
GET http://localhost:8083/fhir/r4/Observation?patient=178
Content-Type: application/json+fhir
Accept: application/json+fhir
retours :
{
"resourceType": "Bundle",
"id": "feaa09c0-1cb7-11ee-b77a-0242c0a88002",
"type": "searchset",
"timestamp": "2023-07-07T11:07:49Z",
"total": 0,
"link": [
{
"relation": "self",
"url": "http://localhost:8083/fhir/r4/Observation?patient=178"
}
]
}
GET http://localhost:8083/fhir/r4/Observation?patient=178
Content-Type: application/json+fhir
Accept: application/json+fhir
Authorization: Basic U3VwZXJVc2VyOlNZUw==
retours :
{
"resourceType": "Bundle",
"id": "953a1b06-1cb7-11ee-b77b-0242c0a88002",
"type": "searchset",
"timestamp": "2023-07-07T11:08:04Z",
"total": 100,
"link": [
{
"relation": "self",
"url": "http://localhost:8083/fhir/r4/Observation?patient=178"
}
],
"entry": [
{
"fullUrl": "http://localhost:8083/fhir/r4/Observation/277",
"resource": {
"resourceType": "Observation",
"id": "277",
"status": "final",
"category": [
...
],
}
},
...
]
}
Vous trouverez plus de détails dans la section suivante "Consentement".
Le système de gestion de consentement est simulé par la méthode consent (consentement) de la classe CustomInteraction (interaction personnalisée) du module custom (personnalisation).
La méthode consent retourne True (vrai) si l'utilisateur a les droits suffisants pour accéder à la ressource, False (faux) dans le cas contraire.
def consent(self, resource_type, user, roles):
#Exemple de logique de consentement: autoriser uniquement les utilisateurs ayant le rôle "%All" à consulter
#les ressources "Observation".
if resource_type == 'Observation':
if '%All' in roles:
return True
else:
return False
else:
return True
La fonction consent fait partie de la classe CustomInteraction.
La classe CustomInteraction est une implémentation de la classe Interaction.
La classe Interaction est une classe abstraite qui doit être implémentée par la stratégie. Elle fait partie du module FhirInteraction.
class Interaction(object):
__metaclass__ = abc.ABCMeta
@abc.abstractmethod
def on_before_request(self,
fhir_service:'iris.HS.FHIRServer.API.Service',
fhir_request:'iris.FHIRServer.API.Data.Request',
body:dict,
timeout:int):
"""
on_before_request est appelé avant que la demande ne soit envoyée au serveur.
param fhir_service: objet service fhir iris.HS.FHIRServer.API.Service
param fhir_request: objet service fhir iris.FHIRServer.API.Data.Request
param timeout: le délai en secondes
return: None
"""
@abc.abstractmethod
def on_after_request(self,
fhir_service:'iris.HS.FHIRServer.API.Service',
fhir_request:'iris.FHIRServer.API.Data.Request',
fhir_response:'iris.FHIRServer.API.Data.Response',
body:dict):
"""
on_after_request est appelée après l'envoi de la demande au serveur.
param fhir_service: objet service fhir iris.HS.FHIRServer.API.Service
param fhir_request: objet requête fhir iris.FHIRServer.API.Data.Request
param fhir_response: objet réponse fhir iris.FHIRServer.API.Data.Response
return: None
"""
@abc.abstractmethod
def post_process_read(self,
fhir_object:dict) -> bool:
"""
post_process_read est appelée après l'opération de lecture.
param fhir_object: objet fhir
return: "True" la ressource doit être renvoyée au client, "False" dans le cas contraire
"""
@abc.abstractmethod
def post_process_search(self,
rs:'iris.HS.FHIRServer.Util.SearchResult',
resource_type:str):
"""
post_process_search est appelée une fois l'opération de recherche terminée.
param rs: résultat de recherche iris.HS.FHIRServer.Util.SearchResult
param resource_type: type de ressource
return: None
"""
La classe CustomInteraction est une implémentation de la classe Interaction.
class CustomInteraction(Interaction):
def on_before_request(self, fhir_service, fhir_request, body, timeout):
#Extraction de l'utilisateur et des rôles pour cette demande
#afin que le consentement puisse être évalué.
self.requesting_user = fhir_request.Username
self.requesting_roles = fhir_request.Roles
def on_after_request(self, fhir_service, fhir_request, fhir_response, body):
#Suppression de l'utilisateur et des rôles entre les demandes.
self.requesting_user = ""
self.requesting_roles = ""
def post_process_read(self, fhir_object):
#Évaluation du consentement en fonction de la ressource et de l'utilisateur/des rôles.
#La valeur 0 indique que cette ressource ne doit pas être affichée - un message 404 Not Found (404 introuvable)
#sera renvoyé à l'utilisateur.
return self.consent(fhir_object['resourceType'],
self.requesting_user,
self.requesting_roles)
def post_process_search(self, rs, resource_type):
#Itération sur chaque ressource de l'ensemble de recherche et évaluation
#du consentement en fonction de la ressource et de l'utilisateur/des rôles.
#Chaque ligne marquée comme supprimée et sauvegardée sera exclue de l'ensemble.
rs._SetIterator(0)
while rs._Next():
if not self.consent(rs.ResourceType,
self.requesting_user,
self.requesting_roles):
#Sélection de la ligne comme supprimée et sauvegarde.
rs.MarkAsDeleted()
rs._SaveRow()
def consent(self, resource_type, user, roles):
#Exemple de logique de consentement: autoriser uniquement les utilisateurs ayant le rôle "%All" à consulter
#les ressources "Observation".
if resource_type == 'Observation':
if '%All' in roles:
return True
else:
return False
else:
return True
Vous pouvez modifier le module custom pour implémenter votre propre logique de consentement.
Toutes les modifications apportées au module custom seront directement reflétées dans le serveur FHIR.
Il est possible d'implémenter d'autres comportements en surchargeant les classes Interaction.
Le serveur IRIS FHIR fournit une ressource CapabilityStatement par défaut en fonction du Guide d'implémentation fourni au moment de l'installation.
De plus amples informations sur la manière de personnaliser la Resource CapabilityStatement sont disponibles à l'adresse FHIR CapabilityStatement.
Pour cet exemple, le Guide d'implémentation est FHIR R4 brut.
Pour personnaliser la ressource CapabilityStatement, vous pouvez modifier le module custom.
La classe CustomStrategy est une implémentation de la classe Strategy(stratégie).
La classe Strategy est une classe abstraite qui doit être implémentée par la stratégie. Elle fait partie du module FhirInteraction.
class Strategy(object):
__metaclass__ = abc.ABCMeta
@abc.abstractmethod
def on_get_capability_statement(self,capability_statement:dict)-> dict:
"""
on_after_get_capability_statement est appelé une fois la déclaration de capacité récupérée.
param capability_statement: la déclaration de capacité
return: None
"""
La méthode on_get_capability_statement est appelée après la génération de la ressource CapabilityStatement.
La classe CustomStrategy est une implémentation de la classe Strategy.
class CustomStrategy(Strategy):
def on_get_capability_statement(self, capability_statement):
# Exemple : Compte de ressources
capability_statement['rest'][0]['resource'] = [resource for resource in capability_statement['rest'][0]['resource'] if resource['type'] != 'Account']
return capability_statement
Vous pouvez modifier le module custom pour implémenter votre propre Custom CapabilityStatement.
Pour appliquer les modifications, vous devez mettre à jour la configuration du serveur fhir.
cd /irisdev/app/src/python
/usr/irissys/bin/irispython
>>> import custom
>>> custom.set_capability_statement()
InterSystems a corrigé deux défauts concernant la connectivité. Ces défauts et leurs corrections sont indépendants les uns des autres.
Cette alerte les concerne tous les deux, car il existe des versions intermédiaires contenant les deux corrections.
Les deux défauts affectent uniquement les versions 2019.1.4 et 2020.1.4 de :
La méthode InstallFoundation est manquante (IRIS 2023.2+)
IRIS 2023.2 est récemment sorti. Cette version a supprimé cette méthode InstallFoundation de cette classe HS.HC.Util.Installer. Il s’agissait d’une méthode privée et elle n’était pas documentée. Mais il a été largement utilisé par la communauté pour installer le serveur FHIR.
Donc si vous rencontrez cette erreur :
<METHOD DOES NOT EXIST> *InstallFoundation,HS.HC.Util.Installer
Pendant que vous créez une démo sur votre propre serveur FHIR, vous pouvez le corriger en remplaçant cette ligne :
do ##class(HS.HC.Util.Installer).InstallFoundation(namespace)
par
Do ##class(HS.Util.Installer.Foundation).Install(namespace)
Salut la Communauté,
prenez plaisir à regarder cette nouvelle vidéo sur InterSystems Developers YouTube:
⏯ Apprendre à connaître FHIR: la meilleure explication de FHIR jamais entendue @ Global Summit 2023
Voici un exemple de déploiement de iris-oauth-fhir sur k3d avec IKO.
Ce sera un long parcours, mais il en vaudra la peine. Vous apprendrez beaucoup de choses sur Kubernetes et InterSystems IRIS for Health.
Commencez par cloner le dépôt :
git clone https://github.com/grongierisc/iris-oauth-fhir
Et construisez l'image iris-oauth-fhir comme il est expliqué dans README.md
Ensuite, nous installerons k3d.
curl -s https://raw.githubusercontent.com/rancher/k3d/main/install.sh | bash
Il est nécessaire de créer un registre car pour l'instant Docker Desktop ne sert pas son registre interne comme un registre containerd. Une fonctionnalité expérimentale est disponible pour exploiter le registre de Docker Desktop en tant que registre containerd, mais elle n'est pas encore stable. Donc nous allons utiliser k3d pour créer un registre.
k3d registry create registry.localhost --port 5000
Cette commande permettra de créer un registre sur le port 5000. Nous l'utiliserons pour envoyer nos images. C'est la seule façon d'utiliser nos images avec k3d.
Maintenant, nous ajouterons le registre à notre fichier d'hôtes. Ainsi, nous pourrons l'utiliser comme un nom DNS. C'est important car nous l'utiliserons dans notre déploiement. Ce nom DNS sera le même pour notre hôte et pour Kubernetes.
sudo sh -c 'echo "127.0.0.1 k3d-registry.localhost" >> /etc/hosts'
Nous lancerons maintenant le cluster à l'aide de la ligne de commande suivante :
k3d cluster create demo --servers 1 --agents 2 --volume $(pwd)/k8s/data:/var/lib/rancher/k3s/storage@all --registry-use k3d-registry.localhost:5000 -p "8081:80@loadbalancer" -p "4443:443@loadbalancer" --api-port 6550 --volume "$(pwd)/k8s/config/traefik-config.yaml:/var/lib/rancher/k3s/server/manifests/traefik-config.yaml"
Les options possibles sont :
--servers 1 créera un noeud serveur, les noeuds serveurs sont les noeuds maîtres.-agents 2 créera deux noeuds agents, les noeuds agents sont les noeuds de travail.--volume $(pwd)/k8s/data:/var/lib/rancher/k3s/storage@all montera le dossier k8s/data sur le cluster. C'est là que nous stockerons nos données.--registry-use k3d-registry.localhost:5000 utilisera le registre que nous avons créé précédemment.-p "8081:80@loadbalancer" -p "4443:443@loadbalancer" exposera les ports 8081 et 4443 à l'hôte. C'est là que nous accéderons à notre cluster.--api-port 6550 exposera le port 6550 à l'hôte. C'est là que nous accéderons à l'API Kubernetes.--volume "$(pwd)/k8s/config/traefik-config.yaml:/var/lib/rancher/k3s/server/manifests/traefik-config.yaml" montera le fichier k8s/config/traefik-config.yaml sur le cluster. Il s'agit du fichier de configuration du contrôleur ingress. Il configure le contrôleur ingress pour permettre à traefik de router les données sur le port sécurisé sans vérification du certificat.# k8s/config/traefik-config.yaml
apiVersion: helm.cattle.io/v1
kind: HelmChartConfig
metadata:
name: traefik
namespace: kube-system
spec:
valuesContent: |-
globalArguments:
- "--serversTransport.insecureSkipVerify=true"
Voici un diagramme pour vous donner une idée de la forme d'un cluster Kubernetes :
kubectl get nodes
Vous obtenez alors quelque chose comme ça :
NOM STATUT RÔLES ÂGE VERSION
k3d-demo-server-0 Prêt plan de commande,maître 10m v1.21.2+k3s1
k3d-demo-agent-0 Prêt <nul> 10m v1.21.2+k3s1
k3d-demo-agent-1 Prêt <nul> 10m v1.21.2+k3s1
Cela signifie que le cluster est prêt. Vous avez maintenant un cluster Kubernetes avec un nœud maître et deux nœuds de travail. 🥳
Nous installerons maintenant iris-operator. iris-operator est un opérateur Kubernetes qui permet de déployer InterSystems IRIS for Health sur Kubernetes. Il est disponible sur le WRC ou sur le registre InterSystems Container Registry. Nous utiliserons la version 3.6.6.100.
Par exemple, si vous disposez d'IKO pour le registre de conteneurs, vous pouvez utiliser la ligne de commande suivante :
docker pull containers.intersystems.com/intersystems/iris-operator-amd:3.6.6.100
Nous marquerons maintenant l'image pour l'envoyer dans notre registre :
docker tag intersystems/iris-operator-amd:3.6.6.100 k3d-registry.localhost:5000/intersystems/iris-operator-amd:3.6.6.100
Et nous l'enverrons :
docker push k3d-registry.localhost:5000/intersystems/iris-operator-amd:3.6.6.100
Pour installer l'opérateur Iko, nous devons utiliser helm. Helm est un gestionnaire de paquets pour Kubernetes. Il est disponible [ici] (https://helm.sh/).
curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
chmod 700 get_helm.sh
./get_helm.sh
helm install intersystems k8s/iris_operator_amd-3.6.6.100/chart/iris-operator
Pour vérifier si l'opérateur fonctionne, vous pouvez utiliser la ligne de commande suivante :
kubectl --namespace=default get deployments -l "release=intersystems, app=iris-operator-amd"
Vous verrez alors quelque chose comme ça :
NOM PRÊT MISE À JOUR DISPONIBLE ÂGE
intersystems-iris-operator 1/1 1 1 2m
L'architecture suivante sera déployée :
C'est exactement ce que nous avons dans le fichier docker-compose suivant :
# docker-compose.yaml
version: '3.6'
services:
iris:
image: iris-oauth-fhir-iris:latest
build:
context: .
dockerfile: Dockerfile
restart: always
ports:
- 1972
- 8083:52773
- 53773
volumes:
- ./:/irisdev/app/
- ./data:/data
environment:
- ISC_CPF_MERGE_FILE=/irisdev/app/common.cpf
- ISC_OAUTH_SECRET_PATH=/irisdev/app/misc/auth/secret.json
- ISC_DATA_DIRECTORY=/data/iris
webgateway:
build:
context: ./webgateway
args:
link: 'iris'
port: '52773'
image: proxyiris:latest
ports:
- "8080:80"
- "4443:443"
volumes:
- ./webgateway/CSP.ini:/opt/webgateway/bin/CSP.ini
- ./webgateway/httpd-csp.conf:/usr/local/apache2/conf/extra/httpd-csp.conf
Quelques remarques :
iris-oauth-fhir-iris:latest pour le noeud de données.
ISC_CPF_MERGE_FILE pour fusionner le fichier common.cpf.ISC_OAUTH_SECRET_PATH pour définir le chemin vers le fichier secret.ISC_DATA_DIRECTORY pour définir le répertoire de données.proxyiris:latest pour le noeud de passerelle web.
CSP.ini pour configurer l'application CSP.
* httpd-csp.conf pour configurer le serveur Apache.Ainsi, nous devrons faire la même chose dans notre déploiement Kubernetes.
C'est à dire que nous devrons :
common.cpf au nœud de données.secret.json pour configurer l'authentification OAuth2.CSP.ini au noeud de passerelle web.httpd-csp.conf pour configurer le serveur Apache.Pour fournir le fichier common.cpf au nœud de données, nous allons utiliser une configuration de carte (config map). Celle-ci est un objet Kubernetes qui permet de stocker des fichiers de configuration. Nous utiliserons le fichier common.cpf que nous avons dans ce référentiel.
Voici une représentation schématique pour une config map :
Nous utiliserons la ligne de commande suivante pour créer une config map :
kubectl create cm iriscluster-config --from-file common.cpf
Nous utiliserons un secret afin de fournir le fichier secret.json au nœud de données. Un secret est un objet Kubernetes permettant de stocker des données sensibles. Nous utiliserons le fichier secret.json présent dans ce référentiel.
Nous utiliserons la ligne de commande suivante pour créer un secret :
kubectl create secret generic iriscluster-secret --from-file misc/auth/secret.json
Le montage du répertoire de données en tant que volume est automatique. Nous utiliserons le champ storage dans la section topology de la définition d'IrisCluster comme valeur par défaut.
Nous devons encore envoyer l'image iris-oauth-fhir-iris:latest dans notre registre. Nous utiliserons la même ligne de commande que précédemment :
docker tag iris-oauth-fhir-iris:latest k3d-registry.localhost:5000/iris-oauth-fhir-iris:latest
docker push k3d-registry.localhost:5000/iris-oauth-fhir-iris:latest
Le nœud de la passerelle web est un peu différent car nous n'utiliserons pas l'image proxyiris:latest. Nous utiliserons l'image intersystems/webgateway:2023.1.1.380.0-linux-amd64. Cette image est disponible sur le registre de conteneurs InterSystems Container Registry.
Cette image est l'image raw (brute) de la passerelle web.
Quelle est la différence entre l'image raw de la passerelle web et l'image proxyiris ?
proxyiris dispose de https préconfiguré avec un certificat auto-signé.Nous devons donc configurer la passerelle web de manière à ce qu'elle utilise https. Pour cela, nous allons utiliser un secret. Un secret est un objet Kubernetes qui permet le stockage de données sensibles. Nous utiliserons les fichiers tls.crt et tls.key présents dans ce référentiel.
Nous utiliserons la ligne de commande suivante pour créer le secret :
kubectl create secret tls tls-secret --key k8s/tls/tls.key --cert k8s/tls/tls.crt
La bonne nouvelle est que nous ne devrons pas configurer l'application CSP et le serveur Apache. Nous utiliserons les champs applicationPaths et alternativeServers dans la section topology de la définition d'IrisCluster et les utiliserons par défaut.
Dans le fichier docker-compose.yaml nous avons dû configurer le fichier CSP.ini et le fichier httpd-csp.conf. Nous ne devrons pas le faire dans le déploiement Kubernetes car l'adresse IP du nœud de données n'est pas connue d'avance. Mais nous devons quand même indiquer à IKO quels seront le login et le mot de passe pour se connecter au nœud de données. À cette fin, nous utiliserons un secret. Un secret est un objet Kubernetes qui permet le stockage de données sensibles. Nous utiliserons le fichier iris-webgateway-secret que nous avons dans ce dépôt.
Nous utiliserons la ligne de commande suivante pour créer le secret :
kubectl create secret generic iris-webgateway-secret --from-literal='username=CSPSystem' --from-literal='password=]]]U1lT'
Nous avons encore besoin d'envoyer l'image intersystems/webgateway:2023.1.1.380.0-linux-amd64 dans notre registre. Nous utiliserons la même ligne de commande que précédemment :
docker tag containers.intersystems.com/intersystems/webgateway:2023.1.1.380.0-linux-amd64 k3d-registry.localhost:5000/intersystems/webgateway:2023.1.1.380.0-linux-amd64
docker push k3d-registry.localhost:5000/intersystems/webgateway:2023.1.1.380.0-linux-amd64
Nous installerons maintenant IrisCluster. IrisCluster est une ressource personnalisée de Kubernetes pour déployer InterSystems IRIS for Health sur Kubernetes.
Elle est définie dans le fichier k8s/config/iris-sample.yaml.
# k8s/config/iris-sample.yaml
## champs décommentés déploient un serveur de données InterSystems IRIS
## AVERTISSEMENT : le mot de passe par défaut n'est pas réinitialisé, pour le réinitialiser, il faut inclure
## configSource ci-dessous
## inclure des champs commentés aux fins décrites ; voir la documentation à l'adresse suivante
## https://docs.intersystems.com/irislatest/csp/docbook/Doc.View.cls?KEY=AIKO_clusterdef_sample
## mettre à jour les balises des images (à partir de ":tag") avant de les utiliser ; voir la liste des images disponibles à l'adresse suivante
## https://docs.intersystems.com/components/csp/docbook/Doc.View.cls?KEY=PAGE_containerregistry
apiVersion: intersystems.com/v1alpha1
kind: IrisCluster
metadata:
name: sample
spec:
## fournir la clé de licence d'InterSystems IRIS si nécessaire
# licenseKeySecret:
# name: iris-key-secret
## spécifier les fichiers utilisés pour personnaliser les configurations
## des nœuds InterSystems IRIS, y compris le paramètre passwordHash
## pour configurer le mot de passe par défaut, sécurisant ainsi les nœuds InterSystems IRIS
configSource:
name: iriscluster-config
## fournir les identifiants du référentiel si nécessaire pour extraire les images
# imagePullSecrets:
# - name: iris-pull-secret
## fournir des spécifications VolumeSource pour les certificats pour chaque fonctionnalité TLS requise
## "common" permet d'activer toutes les fonctionnalités TLS, mais la propriété de chaque fonctionnalité particulière est prioritaire sur "common"
tls:
# common:
# secret:
# secretName: tls-certs
# mirror:
# csi:
# driver: secrets-store.csi.k8s.io
# readOnly: true
# volumeAttributes:
# secretProviderClass: "my-provider"
webgateway:
secret:
secretName: tls-secret
## spécifier la classe de stockage spécifique à la plate-forme utilisée pour allouer de l'espace de stockage
## volumes (par défaut : utilisation de la classe définie par la plate-forme)
# storageClassName: iris-ssd-storageclass
## sélectionner la stratégie de mise à jour (par défaut : RollingUpdate)
# updateStrategy:
# type: RollingUpdate
## créer des adresses IP externes pour le cluster
## ("type: LoadBalancer" et "externalTrafficPolicy: Local" sont nécessaire)
# serviceTemplate:
# spec:
# type: LoadBalancer
# externalTrafficPolicy: Local
## définir les volumes persistants (à monter par "volumeMounts :" dans les définitions de nœuds)
# volumeClaimTemplates:
# - metadata:
# name: extra-disk
# spec:
# accessModes:
# - ReadWriteOnce
# resources:
# requests:
# storage: 2Gi
## définir des volumes éphémères (à monter par "volumeMounts :" dans les définitions de nœuds)
volumes:
- name: auth-config
secret:
secretName: iriscluster-secret
## topologie : définit les types de nœuds à déployer ; uniquement "data :" est nécessaire
topology:
data:
image: k3d-registry.localhost:5000/iris-oauth-fhir-iris:latest
## établir une variable d'environnement pour le conteneur
podTemplate:
spec:
env:
- name: ISC_OAUTH_SECRET_PATH
value: /auth/secret.json
## déployer un cluster de nœuds de données et (éventuellement) de nœuds de calcul;
## s'il n'est pas inclus, la définition "data :" dans "topology :" déploie
## un seul serveur de données, "compute :" ajoute des serveurs d'application
# shards: 2
## déployer des nœuds de données ou des serveurs de données en miroir (par défaut : sans miroir)
# mirrored: true
## remplacer la taille par défaut et d'autres attributs des volumes de stockage prédéfinis
## pour les nœuds de données (noms de volumes supplémentaires : storageWIJ,
## storageJournal1, storageJournal2) ; il peut également être inclus
## dans la définition "compute :"
# storageDB:
# resources:
# requests:
# storage: 10Gi
# storageClassName: my-storageclass
## contraindre les nœuds à des zones de disponibilité spécifiques à la plate-forme
## (peut être inclus dans d'autres définitions de nœuds)
# preferredZones:
# - us-east1-a
# - us-east1-b
## monter les volumes définis dans "volumeClaimTemplates :" (persistant) et "volumes :" (éphémère)
volumeMounts:
- mountPath: "/auth"
name: auth-config
## déployer les nœuds webgateway (serveur web)
webgateway:
image: k3d-registry.localhost:5000/intersystems/webgateway:2023.1.1.380.0-linux-amd64
type: apache
replicas: 1
applicationPaths:
- /csp/sys
- /fhir/r4
alternativeServers: LoadBalancing
loginSecret:
name: iris-webgateway-secret
## déployer le Système d'Alerte et de Surveillance (SAM) avec InterSystems IRIS
# sam:
# image: containers.intersystems.com/intersystems/sam:tag
## déployer le Gestionnaire d'API d'InterSystems (IAM) avec IRIS d'InterSystems
# iam:
# image: containers.intersystems.com/intersystems/iam:tag
Ouah, c'est beaucoup ! Mais ne vous inquiétez pas, nous allons tout vous expliquer.
Commençons donc avec la section configSource :
## spécifier les fichiers utilisés pour personnaliser les configurations
## des nœuds InterSystems IRIS, y compris le paramètre passwordHash
## pour établir le mot de passe par défaut, sécurisant les nœuds InterSystems IRIS
configSource:
name: iriscluster-config
C'est la carte de configuration "config map" que nous avons créée précédemment. C'est là que nous trouverons le fichier common.cpf.
Ensuite, nous avons la section tls :
## fournir des spécifications VolumeSource pour les certificats pour chaque fonctionnalité TLS requise
## "common" permet d'activer toutes les fonctionnalités TLS, mais la propriété de chaque fonctionnalité particulière est prioritaire sur "common"
tls:
webgateway:
secret:
secretName: tls-secret
C'est le secret que nous avons créé précédemment. C'est là que nous trouverons les fichiers tls.crt et tls.key.
Ensuite, nous avons la section volumes :
## définir des volumes éphémères (à monter par "volumeMounts :" dans les définitions de nœuds)
volumes:
- name: auth-config
secret:
secretName: iriscluster-secret
C'est le secret que nous avons créé précédemment. C'est là que nous trouverons le fichier secret.json.
Un IrisCluster définit comment déployer InterSystems IRIS for Health sur Kubernetes. La partie importante est la section topologie. Cette section définit les nœuds à déployer. Dans cet exemple, nous déploierons un nœud de données et un nœud de passerelle web.
Examinons la définition du nœud de données :
## topologie : définit les types de nœuds à déployer ; uniquement "data :" est nécessaire
topology:
data:
image: k3d-registry.localhost:5000/iris-oauth-fhir-iris:latest
## établir une variable d'environnement pour le conteneur
podTemplate:
spec:
env:
- name: ISC_OAUTH_SECRET_PATH
value: /auth/secret.json
volumeMounts:
- mountPath: "/auth"
name: auth-config
Le champ image définit l'image à utiliser. Nous utiliserons l'image que nous avons construite précédemment. Le champ podTemplate définit le modèle de pod Kubernetes. Le champ env définit les variables d'environnement à définir dans le conteneur. Nous utiliserons cette variable d'environnement pour définir le chemin vers le fichier secret que nous allons créer.
podTemplate c'est en quelque sorte ce que vous pouvez trouver dans un fichier docker-compose.yaml.
Le champ volumeMounts définit les volumes à monter dans le conteneur. Nous monterons le secret que nous avons créé précédemment.
Examinons maintenant la définition du nœud de passerelle web :
## déployer les nœuds de passerelle web (webgateway) (serveur web)
webgateway:
image: k3d-registry.localhost:5000/intersystems/webgateway:2023.1.1.380.0-linux-amd64
type: apache
replicas: 1
applicationPaths:
- /csp/sys
- /fhir/r4
alternativeServers: LoadBalancing
loginSecret:
name: iris-webgateway-secret
Le champ image définit l'image à utiliser. Le champ type définit le type de passerelle web à déployer. Nous utiliserons apache. Le champ replicas définit le nombre de passerelles web à déployer. Nous n'en déploierons qu'une. Le champ applicationPaths définit les chemins d'application à router vers la passerelle web. Nous allons router /csp/sys et /fhir/r4 vers la passerelle web. Le champ alternativeServers définit les serveurs alternatifs à utiliser. Nous utiliserons LoadBalancing. Le champ loginSecret définit le login et le mot de passe pour lier la passerelle au noeud de données.
Nous utiliserons la ligne de commande suivante pour déployer IrisCluster :
kubectl apply -f k8s/config/iris-sample.yaml
Vous pouvez utiliser la ligne de commande suivante pour vérifier si IrisCluster est en cours d'exécution :
kubectl get iriscluster
Quelques minutes plus tard, vous devriez voir apparaître quelque chose comme ceci :
NOM SEGMENTS MIROITÉ STATUT ÂGE
échantillon En cours d'exécution 2m16s
Vous pouvez utiliser cette ligne de commande afin d'obtenir des détails sur l'IrisCluster :
kubectl describe iriscluster sample
Vous pouvez utiliser la ligne de commande suivante pour vérifier si les pods sont en cours d'exécution :
kubectl get pods
Quelques minutes plus tard, vous devriez voir apparaître quelque chose comme ceci :
NOM PRÊT STATUT RESTARTS ÂGE
intersystems-iris-operator-amd-87c955c9c-4zmrj 1/1 En cours d'exécution 0 44m
sample-data-0 1/1 En cours d'exécution 0 4m19s
sample-webgateway-0 0/1 ContainerCreating 0 17s
Vous pouvez utiliser la ligne de commande suivante pour obtenir des informations détaillées sur les pods :
kubectl describe pod sample-data-0
Nous déployons maintenant un ingress. Un ingress est un objet Kubernetes qui permet de router le trafic vers le bon pod. Nous allons utiliser le fichier k8s/config/ingress.yaml.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: ingress
namespace: default
spec:
rules:
- http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: sample-webgateway
port:
number: 443
Cet ingress va router le trafic vers le service sample-webgateway sur le port 443.
Vous pouvez utiliser la ligne de commande suivante pour déployer l' ingress :
kubectl apply -f k8s/config/ingress.yaml
Vous pouvez utiliser la ligne de commande suivante pour vérifier si l'ingress est en cours d'exécution :
kubectl get ingress
Vous pouvez utiliser la ligne de commande suivante pour tester l'ensemble:
curl -k https://localhost:4443/fhir/r4/metadata
Félicitations, vous avez déployé iris-oauth-fhir sur Kubernetes. 🥳
Si vous voulez créer un nouveau client, vous pouvez utiliser le fichier iris-demo.yaml.
En gros, c'est le même fichier que iris-sample.yaml, mais simplement le nom du client est changé.
Vous pouvez le déployer avec la ligne de commande suivante :
kubectl apply -f k8s/config/iris-demo.yaml
Vous pouvez utiliser un nouveau ingress pour acheminer le trafic vers le nouveau client.
apiVersion: traefik.containo.us/v1alpha1
kind: Middleware
metadata:
name: strip-prefix
namespace: default
spec:
stripPrefix:
prefixes:
- /sample
- /demo
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: ingress
namespace: default
annotations:
traefik.ingress.kubernetes.io/router.middlewares: default-strip-prefix@kubernetescrd
spec:
rules:
- http:
paths:
- path: /sample
pathType: Prefix
backend:
service:
name: sample-webgateway
port:
number: 443
- path: /demo
pathType: Prefix
backend:
service:
name: demo-webgateway
port:
number: 443
Deux nouveaux chemins sont ajoutés :
/sample pour router le trafic vers le service sample-webgateway./demo pour router le trafic vers le service demo-webgateway.Vous pouvez dimensionner le nœud de compte et ainsi de suite, mais pour cela vous aurez besoin d'une clé de licence.
Images à étiquettes
docker tag iris-oauth-fhir-iris:latest k3d-registry.localhost:5000/iris-oauth-fhir-iris:latest
docker tag containers.intersystems.com/intersystems/webgateway:2023.1.1.380.0-linux-amd64 k3d-registry.localhost:5000/intersystems/webgateway:2023.1.1.380.0-linux-amd64
docker tag intersystems/iris-operator-amd:3.6.6.100 k3d-registry.localhost:5000/intersystems/iris-operator-amd:3.6.6.100
Images en mode push
docker push k3d-registry.localhost:5000/iris-oauth-fhir-iris:latest
docker push k3d-registry.localhost:5000/intersystems/webgateway:2023.1.1.380.0-linux-amd64
docker push k3d-registry.localhost:5000/intersystems/iris-operator-amd:3.6.6.100
Supprimer un cluster:
k3d cluster delete demo
Créer un cluster:
k3d cluster create demo --servers 1 --agents 2 --volume $(pwd)/k8s/data:/var/lib/rancher/k3s/storage@all --registry-use k3d-registry.localhost:5000 -p "8081:80@loadbalancer" -p "4443:443@loadbalancer" --api-port 6550 --volume "$(pwd)/k8s/config/traefik-config.yaml:/var/lib/rancher/k3s/server/manifests/traefik-config.yaml"
Installer iris-operator:
helm install intersystems k8s/iris_operator_amd-3.6.6.100/chart/iris-operator
Créer Config et Secret
kubectl create cm iriscluster-config --from-file common.cpf
kubectl create secret generic iriscluster-secret --from-file misc/auth/secret.json
kubectl create secret tls tls-secret --key k8s/tls/tls.key --cert k8s/tls/tls.crt
kubectl create secret generic iris-webgateway-secret --from-literal='username=CSPSystem' --from-literal='password=]]]U1lT'
Déployer IrisCluster:
kubectl apply -f k8s/config/iris-sample.yaml
Déployer Ingress:
kubectl apply -f k8s/config/ingress.yaml
L'équipe InterSystems se rend ce week-end au plus grand hackathon du MIT, où nous présenterons un défi technologique pour les hackers.
Nous proposons aux hackers d'utiliser IntegratedML ou InterSystems Supply Chain Orchestrator dans leurs projets afin de concourir pour des prix vraiment sympas !
Si vous êtes à Boston et que vous êtes intéressé pour devenir un mentor InterSystems lors de l'événement, envoyez-moi un message.
InterSystems IRIS Adaptive Analytics version 2023.2 est désormais disponible sur le site InterSystems Software Distribution. Cette nouvelle version apporte de grandes améliorations incluses dans la version 2023.2 de notre partenaire AtScale, notamment :
Actuellement, les privilèges SQL (SELECT, INSERT, UPDATE, DELETE) sont gérés au niveau des tables, ce qui peut s'avérer très fastidieux lorsque vous devez administrer de nombreux rôles dans une organisation et les synchroniser avec des modèles de données en constante évolution.
En gérant les privilèges au niveau des schémas, cela permettra d'accorder des privilèges SELECT et d'autres privilèges DML à *tous* ou *plusieurs schémas* à un rôle|utilisateur, corrigeant ainsi le besoin de synchroniser manuellement les nouvelles tables|vues avec les rôles.
Je reçois généralement des plaintes de nos clients concernant l'actualisation automatique des pages Web BPL et DTL. C'est un problème courant parmi les utilisateurs débutants, mais pour les développeurs expérimentés aussi, ils oublient d'enregistrer les modifications régulièrement et automatiquement la page Web est rechargée, perdant tout le travail effectué.
Bonjour La Communauté,
toute personne ayant (de près ou de loin, avec une préférence pour la 1ère option), une connaissance de l'utilisation d'Amazon QuickSight avec IRIS, est invitée à faire part de son expérience dans cette discussion.
En vous remerciant par avance.
Il s'agit d'un exemple d'application qui démontre comment utiliser le référentiel FHIR InterSystems IRIS for Health pour construire un référentiel FHIR avec l'autorisation OAuth2, le point de terminaison FHIR sera le serveur de ressources tandis que Google OpenId sera le serveur d'autorisation.
Cette partie est inspirée de l'article Ajout de connexion du réseau social Google dans le Portail de gestion d'InterSystems rédigé par yurimarx Marx dans le cadre de la communauté InterSystems.
Créez un nouveau projet dans la plateforme Google Cloud
Dans l'en-tête, cliquez sur Select (sélectionner un projet ) :
Nous utiliserons postman pour la démo, mais si vous souhaitez utiliser l'application d'exemple, vous devrez ajouter les URI de la redirection suivante, il est de même pour les origines JavaScript.
C'est terminé avec la configuration de la plateforme Google Cloud.
git clone https://github.com/grongierisc/iris-oauth-fhir
docker-compose build
secret.json dans le dossier misc/auth, vous pouvez utiliser le secret.json.template comme un modèle.{
"web": {
"client_id": "xxxx",
"project_id": "intersystems-iris-fhir",
"auth_uri": "https://accounts.google.com/o/oauth2/auth",
"token_uri": "https://oauth2.googleapis.com/token",
"auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v3/certs",
"client_secret": "xxxx"
},
"other" : {
"issuer" : "accounts.google.com"
}
}
docker-compose up -d
Le point de terminaison: httsp://localhost:4443/fhir/r4/.
Configurez Postman pour qu'il utilise le certificat auto-signé, voir Documentation Postman.
Créez une nouvelle demande dans Postman et accédez à l'onglet Autorization (autorisation). Sélectionnez OAuth 2.0 comme type :
Le jeton d'accès à l'url est le suivant : https://accounts.google.com/o/oauth2/token
Scopes (les étendues) : openid
L'identifiant du client et le secret client sont ceux que vous avez reçus de la plateforme Google Cloud.
Un voyage passionnant, j'espère que vous l'avez apprécié.
Plus à venir, restez connectés. Nous aborderons kubernetes et le dépôt FHIR dans la prochaine partie.
pour démonter/monter une base de données, utilisez les méthodes Dismount() et Mount() dans la classe SYS.Database disponible dans l'espace de noms %SYS.
NB : l'ID de la base de données est le nom du chemin absolu de son répertoire.
Vous trouverez quelques exemples de démontage/montage et de méthodes contrôlant si une base de données est montée (Mounted=1) ou non (Mounted=0), ou affichant rapidement tous les attributs d'une base de données (via zwrite)
Dans cet article, nous allons apprendre les sujets ci-dessous répertoriés ci-dessous :
Alors commençons.
Dans cet article, nous aborderons les sujets suivants
Alors commençons.
Salut les développeurs !
Voici les bonus technologiques pour le Concours Python InterSystems 2023 qui vous donneront des points supplémentaires lors du vote :
Bonjour la communauté,
je vous invite à regarder la nouvelle vidéo sur InterSystems Developers YouTube:
Imaginons que vous soyez un développeur Python ou que vous disposiez d'une équipe bien formée et spécialisée en Python, mais que le délai dont vous disposez pour analyser certaines données dans IRIS est serré. Bien entendu, InterSystems propose de nombreux outils pour toutes sortes d’analyses et de traitements. Cependant, dans le scénario donné, il est préférable de faire le travail en utilisant les bons vieux Pandas et de laisser l'IRIS pour une autre fois.
À l'installation d'IRIS, tous les événements d'AUDIT système ne sont pas activés.
Quel est le moyen le plus rapide pour activer tous les événements ?
Système > Gestion de la sécurité > Événements d'audit système
Salut Developer Community,
Je télécharge un fichier Excel xlsx à partir du Web à l'aide de la méthode ci-dessous et je l'enregistre au format xlsx. Comment puis-je convertir et enregistrer un format xlsx au format csv ?
Je recherche dans DBeaver un moyen efficace permettant de filtrer les tables systèmes (ex: appartenant à un schéma commençant par "%").
En utilisant un utilisateur possédant le rôle %All, DBeaver nous affiche une longue liste de schémas systèmes, qui nous oblige à descendre la liste avant d'accéder aux tables utilisateurs.
En créant un utilisateur dans IRIS avec des droits restreints permet de réduire cette liste, mais on perd l'intérêt du rôle %All.
Nous sommes heureux d'annoncer que DBeaver prend en charge InterSystems IRIS dès la version 7.2.4. Vous n'avez plus besoin de le configurer manuellement, recherchez simplement l'icône IRIS dans la liste des connexions.
.png)
Vous pouvez voir l'espace disponible libre pour la base de données à l'aide du bouton radio « Vue de l'espace libre » dans le portail de gestion : Exploitation du système > Bases de données.
Et il peut être obtenu par programmation par la requête FreeSpace de la classe système SYS.Database.
.png)
Il arrive parfois que suite à un événement indésirable la base d'AUDIT (IRISAUDIT) ait pris des proportions telles que le disque sur lequel elle réside soit plein et qu'on ne peut attendre la purge quotidienne pour récupérer l'espace disque.