0 Abonnés · 17 Publications

Caché Server Pages (CSP) est à la fois une architecture et un ensemble d'outils utilisés pour créer des applications web interactives avec la plateforme de données InterSystems.

Article Guillaume Rongier · Sept 10, 2025 5m read

img

Cet article vous présente le concept des environnements virtuels en Python, qui sont essentiels pour gérer les dépendances et isoler les projets du système d'exploitation.

Qu'est-ce qu'un environnement virtuel?

Un environnement virtuel est un dossier qui contient :

  • Une version spécifique de Python
  • Au démarrage, un répertoire site-packages vide

Les environnements virtuels vous aideront à isoler votre projet de l'installation Python du système d'exploitation et d'autres projets.

Utilisation

Pour utiliser les environnements virtuels, vous pouvez suivre les étapes suivantes:

  1. Création d'un environnement virtuel: Vous pouvez créer un environnement virtuel à l'aide du module venv fourni avec Python. Ouvrez votre terminal et exécutez:

    python -m venv .venv
    

    Remplacez .venv par le nom de l'environnement souhaité.

  2. Activation de l'environnement virtuel: Après avoir créé l'environnement virtuel, vous devez l'activer. La commande varie en fonction de votre système d'exploitation:

    • Sous Windows:
    .venv\Scripts\Activate.ps1
    

    Si vous rencontrez une erreur, vous devrez peut-être exécuter la commande suivante dans votre terminal

    Set-ExecutionPolicy -ExecutionPolicy Bypass -Scope Process -Force; .venv\Scripts\Activate.ps1
    
    • Sous macOS et Linux:
    source .venv/bin/activate
    

Une fois activé, le prompt de votre terminal se modifie pour indiquer que vous travaillez désormais dans l'environnement virtuel.

Exemple:

(.venv) user@machine:~/project$

Remarquez le préfixe (.venv) du prompt du terminal, qui indique que l'environnement virtuel est actif.

Vous pouvez maintenant installer des packages à l'aide de pip. Ils seront installés dans l'environnement virtuel plutôt que dans l'installation globale de Python.

Puis-je utiliser des environnements virtuels dans IRIS?

Bonne question!

La réponse est simple : oui et non.

  • Non, puisque IRIS ne prend pas officiellement en charge les environnements virtuels.
  • Oui, puisque après avoir lu tous ces articles, nous connaissons désormais le fonctionnement de Python, celui d'IRIS et nous savons ce qu'est un environnement virtuel. Nous sommes donc peut-être en mesure de simuler un environnement virtuel dans IRIS en utilisant les configurations et les paramètres appropriés.

Comment simuler un environnement virtuel dans IRIS?

Un environnement virtuel comprend deux éléments:

  • Une version spécifique de Python
  • Un répertoire site-packages

IRIS dispose d'un système appelé Flexible Python Runtime (environnement d'exécution Python flexible) qui nous donne la possibilité suivante:

  • utiliser une version spécifique de Python.
  • mettre à jour le sys.path pour inclure un répertoire spécifique.

Nous pouvons donc simuler un environnement virtuel dans IRIS en utilisant leFlexible Python Runtime et en configurant le sys.path pour inclure un répertoire spécifique et une version spécifique de Python. 🥳

La configuration d'un Flexible Python Runtime dans IRIS est facile, vous pouvez suivre les étapes décrites dans la documentation IRIS.

En bref, il faut:

  1. Configurez PythonRuntimeLibrary pour l'orienter vers le fichier lib python de la version Python spécifique que vous souhaitez utiliser.

    Exemple:

    • Windows : C:\Program Files\Python311\python3.dll (Python 3.11 sous Windows)
    • Linux : /usr/lib/x86_64-linux-gnu/libpython3.11.so.1.0 (Python 3.11 sous Ubuntu 22.04 avec architecture x86)
  2. Configurez le PythonPath pour l'orienter vers le répertoire site-packages de la version Python spécifique que vous souhaitez utiliser.

    Exemple:

    • Utilisez le répertoire site-packages de votre environnement virtuel, qui se trouve généralement dans le répertoire .venv/lib/python3.x/site-packages.

⚠️ Ainsi, toute votre instance IRIS sera configurée pour l'utilisation d'une version spécifique de Python et d'un répertoire site-packages spécifique.

🩼 Limitation :

  • Vous n'obtiendrez pas exactement le même sys.path que pour un environnement virtuel, car IRIS ajoutera automatiquement certains répertoires au sys.path, tels que <installation_directory>/lib/python et d'autres que nous avons examinés dans l'article sur les modules.

🤫 Si vous souhaitez automatiser cette opération, vous pouvez utiliser ce formidable package: iris-embedded-python-wrapper

Pour l'utiliser, il faut:

Que vous soyez dans votre environnement venv, puis installez le package:

(.venv) user@machine:~/project$
pip install iris-embedded-python-wrapper

Ensuite, liez simplement ce venv à IRIS à l'aide de la commande suivante:

(.venv) user@machine:~/project$
bind_iris

Vous verrez le message suivant:

INFO:iris_utils._find_libpyton:Created backup at /opt/intersystems/iris/iris.cpf.0f4a1bebbcd4b436a7e2c83cfa44f515
INFO:iris_utils._find_libpyton:Created merge file at /opt/intersystems/iris/iris.cpf.python_merge
IRIS Merge of /opt/intersystems/iris/iris.cpf.python_merge into /opt/intersystems/iris/iris.cpf
INFO:iris_utils._find_libpyton:PythonRuntimeLibrary path set to /usr/local/Cellar/python@3.11/3.11.13/Frameworks/Python.framework/Versions/3.11/Python
INFO:iris_utils._find_libpyton:PythonPath set to /xxxx/.venv/lib/python3.11/site-packages
INFO:iris_utils._find_libpyton:PythonRuntimeLibraryVersion set to 3.11

Pour dissocier le venv d'IRIS, vous pouvez utiliser la commande suivante:

(.venv) user@machine:~/project$
unbind_iris

Conclusion

Vous avez découvert les avantages de l'utilisation d'environnements virtuels en Python, la manière de les créer et de les utiliser, ainsi que la manière de simuler un environnement virtuel dans IRIS à l'aide du Flexible Python Runtime.

0
1 30
Article Guillaume Rongier · Sept 4, 2025 6m read

img

Les modules, quel sujet ! Nous n'avons pas de notion équivalente en ObjectScript, mais c'est un concept fondamental en Python. Découvrons-le ensemble.

Qu'est-ce qu'un module?

Je considère les modules comme une couche intermédiaire entre les classes et les packages. Voici un exemple.

Un mauvais exemple :

# MyClass.py
class MyClass:
    def my_method(self):
        print("Hello from MyClass!")

Lorsque vous voulez utiliser cette classe dans un autre script, vous devez faire comme suit:

# class_usage.py
from MyClass import MyClass # weird, right?

my_instance = MyClass()
my_instance.my_method()

En quoi cet exemple est-il mauvais?

Tout d'abord, parce que les noms de fichiers doivent être écrits en snake_case conformément à la norme PEP 8, et qu'ils doivent donc être nommés my_class.py. Ensuite, parce que vous importez une classe à partir d'un fichier qui porte le même nom que la classe. Ce n'est pas une bonne pratique en Python.

Je sais que cela peut être déroutant, surtout si vous venez d'ObjectScript où les classes sont définies dans des fichiers portant le même nom que celui de la classe.

Notions avancées

Un module est un fichier Python

Donc, nous venons de voir que les modules peuvent être des fichiers Python, mais sans l'extension .py.

Mais attendez, cela signifie-t-il qu'un script python est également un module? Oui, tout à fait!

C'est pourquoi il faut être prudent lorsque vous importez un script, car celui-ci exécutera le code qui y est contenu. Consultez l'article Introduction à Python pour en savoir plus.

Un module est un dossier contenant un fichier __init__.py

Comment ça, un dossier peut être un module? Oui, c'est possible!

Un dossier peut être un module s'il contient un fichier __init__.py. Ce fichier peut être vide ou contenir le code d'initialisation du module.

Voici un exemple:

src/python/article/
└── my_folder_module/
    ├── __init__.py
    ├── my_sub_module.py
    └── another_sub_module.py
# my_folder_module/my_sub_module.py
class MySubModule:
    def my_method(self):
        print("Hello from MySubModule!")
# my_folder_module/another_sub_module.py
class AnotherSubModule:
    def another_method(self):
        print("Hello from AnotherSubModule!")
# my_folder_module/__init__.py
# Ce fichier peut être vide ou contenir le code d'initialisation du module.

Dans ce cas, my_folder_module est un module, et vous pouvez l'importer comme suit:

from my_folder_module import my_sub_module, another_sub_module

Ou si vous définissez un fichier __init__.py avec le contenu suivant:

# my_folder_module/__init__.py
from .my_sub_module import MySubModule
from .another_sub_module import AnotherSubModule

Vous pouvez l'importer de la manière suivante:

from my_folder_module import MySubModule, AnotherSubModule

Vous voyez la subtilité ? Vous pouvez importer les classes directement depuis le module sans spécifier le sous-module, car le fichier __init__.py est exécuté lorsque vous importez le module, et ce fichier peut définir les éléments disponibles dans l'espace de noms du module.

sys.path

Lorsque vous importez un module, Python le recherche dans les répertoires spécifiés dans le fichier sys.path. Il s'agit d'une liste de chaînes de caractères qui spécifie le chemin de recherche des modules.

Vous pouvez afficher le sys.path actuel en exécutant le code suivant:

import sys
print(sys.path)

Par défaut, le répertoire actuel ainsi que d'autres répertoires variés en fonction de votre installation Python sont inclus.

Vous pouvez également ajouter des répertoires à sys.path lors de l'exécution, ce qui est utile lorsque vous souhaitez importer des modules à partir d'un emplacement spécifique. Par exemple:

import sys
sys.path.append('/path/to/your/module')
from your_module import YourClass

Pour cette raison, dans l'article précédent, nous avons ajouté le chemin d'accès au module avant de l'importer:

Set sys = ##class(%SYS.Python).Import("sys")
do sys.path.append("/irisdev/app/src/python/article")
set my_module = ##class(%SYS.Python).Import("my_module")

sys.path et autres répertoires

Quels sont les autres répertoires dans sys.path? Il s'agit généralement des répertoires suivants:

  • Le répertoire contenant le script d'entrée (ou le répertoire actuel si aucun script n'est spécifié).
  • Les répertoires de la bibliothèque standard, qui contiennent les modules intégrés fournis avec Python.
  • Les répertoires site-packages contenant les packages tiers installés.

site-packages

Voici comment fonctionne site-packages. Lorsque vous installez un package à l'aide de pip, il est installé dans le répertoire site-packages, qui est automatiquement inclus dans sys.path. Cela vous permet d'importer le package sans avoir à spécifier son emplacement.

🤨🔍 Mais comment et où le répertoire site-packages est-il défini, et par qui?

Le répertoire site-packages est créé lors de l'installation de Python et se trouve généralement dans le répertoire lib de votre installation Python. Son emplacement exact dépend de votre système opérationnel et de la manière dont Python a été installé.

Par exemple, sur une installation Linux classique, le répertoire site-packages peut être accessible à l'emplacement suivant:

/usr/local/lib/python3.x/site-packages

Sous Windows, il peut se trouver à l'emplacement suivant:

C:\Python3x\Lib\site-packages

Lorsque vous installez un package à l'aide de pip, il est installé dans le répertoire site-packages, qui est automatiquement inclus dans sys.path. Cela vous permet d'importer le package sans avoir à spécifier son emplacement.

import site
print(site.getsitepackages())

🤨🔍 A quel moment et à quel endroit l'interpréteur Python lit-il le fichier site.py?

Le fichier site.py (qui se trouve dans le répertoire standard de la bibliothèque) est exécuté automatiquement au lancement de l'interpréteur Python. Il est responsable de la configuration du répertoire site-packages et de son ajout à sys.path. Ce fichier se trouve dans le répertoire standard de la bibliothèque de votre installation Python.

sys.path dans IRIS

Dans IRIS, nous avons également un fichier site.py, qui se trouve dans <installation_directory>/lib/python/iris_site.py. Ce fichier est exécuté lorsque vous démarrez ou importez un script/module dans IRIS, et il configure le sys.path pour vous.

En résumé, le fichier iris_site.py effectue les opérations suivantes:

  • il préserve le répertoire site-packages par défaut
  • il ajoute le répertoire <installation_directory>/lib/python/ à sys.path
    • c'est là que les modules Python IRIS sont situés, veuillez ne pas y placer vos modules
  • il ajoute le répertoire <installation_directory>/mgr/python/ à sys.path
    • c'est là que vous pouvez placer vos modules Python personnalisés
  • il ajoute la chaîne de configuration PythonPath à sys.path

Conclusion

Un module peut être:

  • un fichier Python (avec ou sans l'extension .py)
  • un dossier contenant un fichier __init__.py
  • un script Python (qui est également un module)
  • si vous ne réussissez pas à importer un module, vérifiez s'il se trouve dans la liste sys.path
0
0 21
Article Guillaume Rongier · Juin 23, 2025 27m read

Introduction

Dans le contexte actuel où les menaces évoluent rapidement, les organisations qui déploient des applications critiques doivent mettre en œuvre des architectures de sécurité robustes qui protègent les données sensibles tout en maintenant une haute disponibilité et des performances élevées. Cela est particulièrement crucial pour les entreprises qui utilisent des systèmes de gestion de bases de données avancés tels qu'InterSystems IRIS, qui alimentent souvent des applications traitant des données hautement sensibles dans les domaines de la santé, de la finance ou des données personnelles.

Cet article décrivent en détail une architecture de sécurité complète à plusieurs niveaux pour le déploiement de clusters InterSystems IRIS sur AWS à l'aide de Kubernetes (EKS) et InterSystems IAM. En appliquant les principes de défense en profondeur, cette architecture fournit une protection à tous les niveaux, du périmètre du réseau au niveau de l'application et du stockage des données.

Pourquoi une approche à plusieurs niveaux est-elle importante

Les stratégies de sécurité à un seul niveau sont de plus en plus inadéquates face à des vecteurs d'attaque sophistiqués. Lorsqu'un contrôle de sécurité échoue, des niveaux supplémentaires doivent être mis en place pour éviter une compromission totale. Notre architecture implémente des contrôles de sécurité à cinq niveaux critiques:

  1. Sécurité périmétrique: Utilisation d'AWS WAF et CloudFront pour filtrer le trafic malveillant avant qu'il n'atteigne vos services
  2. Sécurité réseau: Exploitation des stratégies réseau AWS VPC, des groupes de sécurité et de Kubernetes
  3. Sécurité des API: Implémentation d'InterSystems IAM avec des plug-ins de sécurité avancés
  4. Sécurité des applications: Renforcement de la passerelle Web grâce à des restrictions URI rigoureuses
  5. Sécurité des bases de données: Configuration du cluster IRIS avec authentification et chiffrement robustes

À la fin de cet article, vous comprendrez comment mettre en œuvre chaque couche de sécurité et comment elles fonctionnent conjointement pour créer une stratégie de défense en profondeur qui protège vos déploiements IRIS contre un large éventail de menaces tout en préservant les performances et l'évolutivité.
 


Aperçu de l'architecture

Notre architecture de sécurité repose sur le principe de la défense en profondeur, chaque niveau fournissant une protection complémentaire. Voici un aperçu général de la solution complète:


Structure de déploiement du cluster IRIS

Notre cluster IRIS est déployé à l'aide de l'Opérateur Kubernetes d'InterSystems (IKO) selon une topologie soigneusement conçue:

  1. Niveau de données: Deux instances IRIS dans une configuration en miroir pour une haute disponibilité et une redondance des données
  2. Niveau d'application: Deux serveurs d'applications IRIS qui accèdent aux données via ECP (Enterprise Cache Protocol)
  3. Passerelle API: InterSystems IAM (basé sur Kong) pour la gestion et la sécurité des API
  4. Passerelle Web: Trois instances de passerelle Web (CSP+Nginx) pour traiter les requêtes Web
  5. Arbitre: Une instance d'arbitre pour le niveau de données en miroir

Cette architecture sépare les problèmes et fournit plusieurs niveaux de redondance:

  • Le niveau de données gère les opérations de base de données avec mise en miroir synchrone
  • Le niveau d'application se concentre sur le traitement de la logique métier
  • Le niveau IAM gère la sécurité des API
  • Le niveau de passerelle Web traite les requêtes HTTP/HTTPS

Chaque composant joue un rôle spécifique dans la pile de sécurité:

  1. AWS WAF (pare-feu d'application Web): filtre le trafic malveillant à l'aide d'ensembles de règles qui protègent contre les exploits Web courants, les injections SQL et les scripts intersites (XSS). Il met également en œuvre une liste blanche d'URI pour restreindre l'accès aux seuls chemins d'application légitimes.
  2. AWS CloudFront: Agit comme un réseau de diffusion de contenu (CDN) qui met en cache le contenu statique, réduisant ainsi la surface d'attaque en traitant les demandes à la périphérie. Il fournit également un niveau supplémentaire de protection contre les attaques DDoS.
  3. AWS ALB (Équilibreur de charge d'application): Configuré comme un contrôleur d'entrée Kubernetes, il effectue la terminaison TLS et achemine le trafic vers les services backend appropriés en fonction des chemins d'URL.
  4. InterSystems IAM: Basée sur Kong, cette passerelle API applique l'authentification, l'autorisation, la limitation du débit et la validation des requêtes avant que le trafic n'atteigne l'application.
  5. Passerelle Web: La passerelle Web InterSystems, avec sa configuration renforcée, restreint l'accès à des chemins URI spécifiques et fournit une validation supplémentaire.
  6. Cluster IRIS: La base de données IRIS déployée dans un cluster Kubernetes avec une configuration sécurisée, un chiffrement TLS et des contrôles d'accès basés sur les rôles.

Cette approche à plusieurs niveaux garantit que même si un contrôle de sécurité est contourné, les autres restent en place pour protéger vos applications et vos données.


Niveau 1: Sécurité périmétrique avec AWS WAF et CloudFront

La première ligne de défense de notre architecture se situe au périmètre du réseau, où nous mettons en œuvre AWS WAF et CloudFront pour filtrer le trafic malveillant avant qu'il n'atteigne nos services.

1.1 Mise en œuvre d'AWS WAF

Le pare-feu d'application Web AWS est configuré avec des ensembles de règles personnalisées afin de protéger contre les exploits Web courants et de restreindre l'accès aux chemins URI autorisés uniquement. Voici comment nous l'avons configuré:

# WAF Configuration in Ingress alb.ingress.kubernetes.io/wafv2-acl-arn: arn:aws:wafv2:region-1:ACCOUNT_ID:regional/webacl/app_uri_whitelisting/abcdef123456 

Nos règles WAF sont les suivantes:

  • Liste blanche des chemins URI: Autorisation du trafic uniquement vers les chemins d'application spécifiés, tels que /app/, /csp/broker/, /api/, and /csp/appdata
  • Protection contre les injections SQL: Blocage des requêtes contenant des modèles d'injection SQL
  • Protection XSS: Filtrage des requêtes contenant des charges utiles de type cross-site scripting
  • Regles basées sur les taux: Blocage automatique des adresses IP qui dépassent les seuils de requêtes
  • Règles de limitation géographique: Limitation de l'accès à certaines zones géographiques lorsque cela est nécessaire

En appliquant ces règles à la périphérie, nous empêchons une grande partie du trafic malveillant d'atteindre notre infrastructure d'applications.
 

1.2 Intégration CloudFront

AWS CloudFront fonctionne avec WAF pour fournir des avantages supplémentaires en matière de sécurité:

  • Mise en cache intelligente: le contenu statique est mis en cache à des emplacements périphériques, ce qui réduit la charge sur les services backend et minimise la surface d'attaque
  • Protection contre les attaques DDoS: L'infrastructure distribuée à l'échelle globale de CloudFront aide à absorber les attaques DDoS
  • Application du protocole TLS: Toutes les connexions sont sécurisées à l'aide du protocole TLS 1.2+ et de suites de chiffrement modernes
  • Identité d'accès à l'origine: Garantie que les compartiments S3 hébergeant du contenu statique sont uniquement accessibles via CloudFront

CloudFront est configuré pour transférer des en-têtes spécifiques vers les services backend, garantissant ainsi la préservation des contextes de sécurité tout au long du flux de requêtes:

  • X-Forwarded-For
  • X-Real-IP

Cette configuration permet aux services en aval d'identifier l'adresse IP client d'origine à des fins de limitation du débit et de journalisation, même lorsque les requêtes transitent par plusieurs niveaux.


Niveau 2: Sécurité réseau avec AWS VPC et groupes de sécurité

Le deuxième niveau de notre architecture de sécurité se concentre sur les contrôles au niveau du réseau mis en œuvre via AWS VPC, les groupes de sécurité et les stratégies réseau Kubernetes.

2.1 Conception VPC pour l'isolation

Notre déploiement IRIS s'exécute dans un VPC personnalisé avec les caractéristiques suivantes:

  • Sous-réseaux privés: Tous les pods IRIS et IAM s'exécutent dans des sous-réseaux privés sans accès direct à l'Internet
  • Passerelles NAT: Outbound internet access
  • Plusieurs zones de disponibilité: Les ressources sont réparties sur trois zones de disponibilité pour une haute disponibilité

Cette conception garantit qu'aucun service backend n'est directement exposé à l'Internet, tout le trafic passant par des points d'entrée contrôlés.

2.2 Configuration des groupes de sécurité

Les groupes de sécurité agissent comme des pare-feu virtuels qui contrôlent le trafic entrant et sortant. Notre implémentation comprend plusieurs groupes de sécurité avec des règles rigoureusement définies:

# Groupes de sécurité référencés dans Ingress alb.ingress.kubernetes.io/security-groups: sg-000000000, sg-0100000000, sg-012000000, sg-0130000000  Ces groupes de sécurité mettent en œuvre:
  • Règles d'entrée: N'autorisent le trafic que sur les ports requis (443 pour HTTPS)
  • Restrictions IP source: Limitent l'accès à des blocs CIDR spécifiques pour les interfaces administratives
  • Règles de sortie: Restriction des connexions sortantes aux destinations nécessaires

Ce niveau de contrôle très précis garantit que, même si un conteneur est compromis, sa capacité à communiquer avec d'autres ressources est limitée par les règles du groupe de sécurité.

2.3 Stratégies réseau Kubernetes

Au sein du cluster EKS, nous mettons en œuvre des stratégies réseau Kubernetes afin de contrôler la communication de pod à pod:

apiVersion:networking.k8s.io/v1kind:NetworkPolicymetadata:
  name:allow-iam-webgateway
  namespace:app1spec:
  podSelector:
    matchLabels:
      app.kubernetes.io/component:webgateway
  policyTypes:
    -Ingress
  ingress:
    -ports:
        -protocol:TCP
          port:443

 

Ces stratégies garantissent que:

  • Les pods IRIS n'acceptent que les connexions provenant de sources autorisées (passerelle Web, IAM)
  • Les pods IAM n'acceptent que les connexions provenant du contrôleur Ingress
  • Les pods de passerelle Web n'acceptent que les connexions provenant d'IAM

Cette approche de sécurité réseau à plusieurs niveaux crée des périmètres d'isolation qui contiennent les violations de sécurité potentielles et limitent les mouvements latéraux au sein de l'environnement d'application.


Niveau 3: Sécurité des API avec IAM d'InterSystems

Au cœur de notre architecture de sécurité se trouve IAM d'InterSystems , une solution de gestion des API puissante basée sur Kong. Ce composant fournit des fonctionnalités de sécurité essentielles, notamment l'authentification, l'autorisation, la limitation du débit et la validation des requêtes.

3.1 Aperçu d'IAM d'InterSystems

IAM d'InterSystems sert de passerelle API pour toutes les requêtes adressées aux services IRIS, garantissant que seul le trafic autorisé et légitime atteint votre application. Dans notre implémentation, IAM est déployé en tant que StatefulSet au sein du même cluster Kubernetes que les instances IRIS, ce qui permet une intégration transparente tout en maintenant l'isolation des préoccupations.

La passerelle IAM est configurée avec une terminaison TLS/SSL et n'est exposée que par des points de terminaison sécurisés. Toutes les communications entre IAM et la passerelle Web IRIS sont cryptées, ce qui garantit la confidentialité des données en transit.

3.2 Configuration avancée de la limitation des taux

Afin de vous protéger contre les attaques par déni de service et l'utilisation abusive de l'API, nous avons mis en place une limitation avancée des taux via le rate-limiting-advanced plugind'IAM. Cette configuration utilise Redis comme magasin backend pour suivre les taux de requêtes sur les instances IAM distribuées.

{ "name": "rate-limiting-advanced", "config": { "identifier": "ip", "strategy": "redis", "window_type": "sliding", "limit": [2000, 3000], "window_size": [60, 60], "redis": { "host": "my-release-redis-master.default.svc.cluster.local", "port": 6379, "timeout": 2000, "keepalive_pool_size": 30 }, "error_message": "API rate limit exceeded" } }  

Cette configuration fournit deux niveaux de limitation des taux:

  • Niveau 1: 2,000 requêtes par minute avec une fenêtre glissante
  • Niveau 2: 3,000 requêtes par minute avec une fenêtre glissante

L'approche par fenêtre glissante fournit une limitation des taux plus précise que les fenêtres fixes, empêchant ainsi les pics de trafic aux périmètres des fenêtres. Lorsqu'un client dépasse ces limites, il reçoit un code d'état 429 accompagné d'un message d'erreur personnalisé.

3.3 Gestion sécurisée des sessions

Pour les applications nécessitant des sessions utilisateur, nous avons configuré le plugin de session IAM avec des paramètres sécurisés afin d'empêcher le détournement de session et de maintenir un cycle de vie approprié à la session:

{ "name": "session", "config": { "secret": "REDACTED", "cookie_secure": true, "cookie_same_site": "Strict", "cookie_http_only": true, "idling_timeout": 900, "absolute_timeout": 86400, "rolling_timeout": 14400 } }

Les principales fonctionnalités de sécurité mises en œuvre sont les suivantes:

  • Uniquement des cookies HTTP: Cela empêche JavaScript d'accéder aux cookies de session, ce qui atténue les attaques XSS
  • Indicateur de sécurité: Assure que les cookies ne sont envoyés que via des connexions HTTPS
  • Restriction au même site: empêche les attaques CSRF en limitant l'utilisation des cookies aux requêtes provenant du même site
  • Plusieurs mécanismes de timeout:
    • Timeout d'inactivité (15 minutes): Met fin aux sessions après une période d'inactivité
    • Timeout glissant (4 heurs): Nécessite une réauthentification périodique
    • Timeout absolu (24 heurs): Durée maximale de la session, quelle que soit l'activité

3.4 Validation des requêtes pour la sécurisation des entrées

Afin de nous protéger contre les attaques par injection et les requêtes malformées, nous avons mis en place une validation de requêtes stricte à l'aide du plugin de validation des requêtes IAM. Cela est particulièrement important pour sécuriser le broker CSP, qui est un composant essentiel chargé de gérer la communication client-serveur dans les applications InterSystems.

{ "name": "request-validator", "config": { "version": "kong", "body_schema": [ { "RequestParam": { "type": "integer", "required": true, "between": [1, 10] } }, { "EventType": { "type": "string", "required": true, "match": "^[a-zA-Z0-9$_]{100}$" } }, { "SessionID": { "type": "string", "required": true, "match": "^00b0[a-zA-Z0-9]{40}$" } } ], "verbose_response": true, "allowed_content_types": ["application/x-www-form-urlencoded"] } } 

Cette configuration impose des règles de validation rigoureuses:

  • Les champs de saisie doivent correspondre exactement aux types de données et aux contraintes
  • Les entrées de chaîne doivent correspondre à des modèles d'expressions régulières spécifiques
  • Les types de contenu autorisés sont les seuls acceptés

Le broker CSP est particulièrement sensible, car il sert de canal de communication entre les navigateurs clients et le serveur IRIS. En validant toutes les requêtes au niveau IAM avant qu'elles n'atteignent le broker, nous créons une barrière de sécurité supplémentaire qui protège contre les requêtes malformées ou malveillantes ciblant ce composant critique. Lorsqu'une requête échoue à la validation, l'IAM renvoie une réponse d'erreur détaillée qui aide à identifier le problème de validation sans révéler d'informations sensibles sur vos systèmes backend.

3.5 Configuration d'adresses IP fiables/p>

Pour renforcer encore davantage la sécurité, l'IAM est configuré pour reconnaître les proxys fiables et déterminer correctement les adresses IP des clients:

{ "trusted_ips": [ "10.0.0.0/24", "10.1.0.0/24", "10.0.3.0/24" ], "real_ip_header": "X-Forwarded-For", "real_ip_recursive": "on" }

Cette configuration garantit que:

  • La limitation du taux identifie correctement les adresses IP des clients, même via des proxys
  • Les règles de sécurité utilisant l'identification IP fonctionnent correctement
  • Les journaux d'accès enregistrent les adresses IP réelles des clients plutôt que celles des proxys

En implémentant ces fonctionnalités de sécurité avancées dans InterSystems IAM, nous avons créé un niveau de sécurité API robuste qui complète les mesures de sécurité périmétrique et réseau tout en protégeant les niveaux application et base de données contre le trafic malveillant ou excessif.


Niveau 4 : Sécurité des applications avec renforcement de la passerelle Web

Le quatrième niveau de notre architecture de sécurité se concentre sur le renforcement de la passerelle Web InterSystems, qui sert d'interface entre la passerelle IAM API et la base de données IRIS.

4.1 Configuration de la passerelle Web dans Kubernetes

TLa passerelle Web est déployée dans le cadre de la ressource personnalisée IrisCluster, avec une configuration spécifique axée sur la sécurité:

webgateway:

  image:containers.intersystems.com/intersystems/webgateway-nginx:2023.3
  type:nginx
  replicas:2
  applicationPaths:
    -/csp/app1
    -/csp/app2
    -/app3
    -/csp/app4
    -/app5
    -/csp/bin
  alternativeServers:LoadBalancing
  loginSecret:
    name:iris-webgateway-secret

Cette configuration limite la passerelle Web à la prise en charge de chemins d'accès spécifiques aux applications, ce qui réduit la surface d'attaque en empêchant l'accès aux points de terminaison non autorisés.

4.2 Renforcement de la sécurité de CSP.ini

La configuration CSP.ini de la passerelle Web est renforcée par plusieurs mesures de sécurité:

[SYSTEM]No_Activity_Timeout=480System_Manager=127.0.0.1Maximum_Logged_Request_Size=256KMAX_CONNECTIONS=4096Server_Response_Timeout=60Queued_Request_Timeout=60Default_Server=IRIS[APP_PATH:/app]Alternative_Servers=LoadBalancingAlternative_Server_0=1~~~~~~server-compute-0Response_Size_Notification=ChunkedTransferEncodingandContentLengthKeepAlive=NoActionGZIP_Compression=EnabledGZIP_Exclude_File_Types=jpeggificopnggzzipmp3mp4tiffGZIP_Minimum_File_Size=500

 

Les principales fonctionnalités de sécurité de cette configuration sont les suivantes:

  1. Gestionnaire de système désactivé: L'interface du gestionnaire de système est désactivée, sauf pour localhost
  2. Configuration manuelle uniquement: La configuration automatique est désactivée pour empêcher toute modification non autorisée
  3. Restrictions d'accès aux chemins: Chaque chemin d'application a des paramètres de sécurité spécifiques
  4. Mise en œuvre de l'authentification: AutheEnabled=64 impose l'authentification
  5. Timeout de session: Timeout de session de 15 minutes conformément aux paramètres IAM
  6. Les noms CSP verrouillés: Empêche les attaques transversales en verrouillant les noms CSP

4.3 Configuration avancée de la sécurité Nginx

Notre implémentation utilise une configuration Nginx fortement renforcée pour la passerelle Web, qui fournit plusieurs niveaux de défense:

# Définition d'une liste blanche à l'aide d'une carte

map $request_uri $whitelist_uri {

    default 0;

    "~^/app/.*$" 1;

    "~^/app/.*\.(csp|css|ico|js|png|woff2|ttf|jpg|gif)$" 1;

    "~^/csp/broker/cspxmlhttp.js$" 1;

    "~^/csp/broker/cspbroker.js$" 1;

    "~^/csp/app/.*$" 1;

    "~^/csp/bin/Systems/Module.cxw.*$" 1;

}



# Blocage global d'URI spécifiques
map $request_uri $block_uri {

    default 0;

    "~*%25login" 1;

    "~*%25CSP\.PasswordChange\.cls" 1;

    "~*%25ZEN\.SVGComponent\.svgPage" 1;

}



# Pages d'erreur personnalisées
error_page 403 /403.html;



# Application de la liste blanche d'URI
if ($whitelist_uri = 0) {

    return 403;

}



# Interdirction d'accès aux types de fichiers interdits
location ~* \.(ppt|pptx)$ {

    deny all;

    return 403;

}



# Interdiction d'accès aux URI bloqués
if ($block_uri) {

    return 403;

}



# Journalisation complète for security analysis
log_format security '$real_client_ip - $remote_user [$time_local] '

                   '"$request" $status $body_bytes_sent '

                   '"$http_referer" "$http_user_agent" '

                   '"$http_x_forwarded_for" "$request_body"';

Cette configuration met en œuvre plusieurs commandes de sécurité essentielles:

  1. Liste blanche d'URI: Seuls les chemins explicitement autorisés sont accessibles
  2. Blocage des chemins dangereux: Blocage automatique de l'accès aux points de terminaison dangereux
  3. Blocage des types de fichiers à risque: Cela empêche l'accès aux types de fichiers potentiellement dangereux
  4. Journalisation sécurisée: Journalisation détaillée de toutes les requêtes à des fins d'analyse
  5. Extraction de l'adresse IP client: Extraction correcte des adresses IP réelles des clients à partir des en-têtes X-Forwarded-For
  6. Pages d'erreur personnalisées: Réponses d'erreur standardisées qui ne divulguent pas d'informations sur le système

De plus, nous mettons en œuvre des en-têtes de sécurité renforcés et des limites de requêtes:

# Les en-têtes de sécurité

add_header X-XSS-Protection "1; mode=block" always;

add_header X-Content-Type-Options "nosniff" always;

add_header X-Frame-Options "SAMEORIGIN" always;

add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;

# Limites de taille des tampons et des requêtes

client_max_body_size 50M;

client_body_buffer_size 128k;

client_header_buffer_size 1k;

large_client_header_buffers 4 4k;

# Sécurité SSL/TLS

ssl_protocols TLSv1.2 TLSv1.3;

ssl_prefer_server_ciphers on;

ssl_ciphers 'ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384';

Ces paramètres protègent contre les menaces suivantes:

  • Script inter-sites (XSS)
  • Attaques par confusion de types MIME
  • Clickjacking
  • Attaques par rétrogradation SSL
  • Tentatives de débordement de mémoire tampon
  • Attaques à charge utile importante

4.4 Configuration TLS

La passerelle Web est configurée pour utiliser des paramètres TLS modernes, garantissant ainsi une communication sécurisée:

tls:     

  webgateway:  secret:    secretName:iris-tls-secret

Notre implémentation TLS garantit:

  • Seuls les protocoles TLS 1.2+ sont autorisés
  • Des suites de chiffrement robustes avec confidentialité persistante sont renforcées
  • Les certificats sont correctement validés
  • La gestion des sessions est sécurisée

En mettant en œuvre ce dispositif complet de renforcement de la sécurité de la passerelle Web, nous créons un niveau de sécurité robuste qui protège la base de données IRIS contre les accès non autorisés et les vulnérabilités courantes des applications Web.

Niveau 5: Sécurité des bases de données dans les clusters IRIS

Le dernier niveau de notre architecture de sécurité vise à sécuriser la base de données IRIS elle-même, afin de garantir la protection des données même si tous les niveaux précédents sont compromis.

5.1 Configuration sécurisée d'IrisCluster avec l'Opérateur Kubernetes d'InterSystems (IKO)

Le cluster IRIS est déployé à l'aide de la définition de ressource personnalisée IrisCluster fournie par l'opérateur InterSystems Kubernetes (IKO), avec une configuration axée sur la sécurité:

apiVersion:intersystems.com/v1alpha1kind:IrisClustermetadata:
  name:example-app
  namespace:example-namespacespec:
  tls:     

    common:
      secret:
        secretName:iris-tls-secret
    mirror:
      secret:
        secretName:iris-tls-secret
    ecp:
      secret:
        secretName:iris-tls-secret
  topology:     

    data:
      image:containers.intersystems.com/intersystems/iris:2023.3
      preferredZones:
        -region-1a
        -region-1b
      mirrored:true
      podTemplate:
        spec:
          securityContext:
            runAsUser:51773  # irisowner
            runAsGroup:51773
            fsGroup:51773
      irisDatabases:
        -name:appdata
          mirrored:true
          ecp:true
      irisNamespaces:
        -name:APP
          routines:appdata
          globals:appdata
    compute:
      image:containers.intersystems.com/intersystems/iris:2023.3
      replicas:1
      compatibilityVersion:"2023.3.0"
      webgateway:
        image:containers.intersystems.com/intersystems/webgateway-nginx:2023.3
        replicas:1
        type:nginx
        applicationPaths:
          -/csp/sys
          -/csp/bin
          -/api/app
          -/app
    iam:
      image:containers.intersystems.com/intersystems/iam:3.4
    arbiter:
      image:containers.intersystems.com/intersystems/arbiter:2023.3
      preferredZones:
        -region-1c

Notre déploiement IKO comprend plusieurs fonctionnalités de sécurité essentielles:

  1. Cryptage TLS: Toutes les communications entre les instances IRIS sont cryptées à l'aide du protocole TLS
  2. Mise en miroir de la base de données: Haute disponibilité avec mise en miroir synchronisée garantissant l'intégrité des données
  3. Exécution non root: IRIS s'exécute en tant qu'utilisateur irisowner sans privilèges
  4. Sécurité ECP: Les connexions Enterprise Cache Protocol sont sécurisées avec TLS
  5. Répartition par zone: Les composants sont répartis entre plusieurs zones de disponibilité pour assurer la tolérance aux pannes
  6. Isolation des ressources: Séparation nette entre les données et les nœuds de calcul
  7. Espaces de noms IRIS: Espaces de noms correctement configurés et mappés à des bases de données sécurisées
  8. Nœud arbitre: Nœud arbitre dédié dans une zone de disponibilité distincte

5.2 Paramètres de sécurité de la base de données IRIS

Au sein de la base de données IRIS, les meilleures pratiques en matière de sécurité comprennent la mise en œuvre de plusieurs paramètres de sécurité clés:

  1. Authentification déléguée: Configuration IRIS pour utiliser des mécanismes d'authentification externes pour la gestion centralisée des identités
  2. Journalisation des audits: Activation d'un audit complet pour les événements liés à la sécurité, tels que les connexions, les modifications de configuration et l'augmentation des privilèges
  3. Sécurité du système: application des paramètres de sécurité au niveau du système conformément aux normes de l'industrie

Ces pratiques garantissent une gestion centralisée de l'authentification, la journalisation de toutes les activités liées à la sécurité à des fins d'analyse et la conformité du système aux normes de configuration sécurisées.

5.3 Sécurité basée sur les ressources IRIS

IRIS fournit un cadre de sécurité robuste basé sur les ressources et les rôles qui permet un contrôle d'accès très précis. Ce cadre peut être utilisé pour mettre en œuvre le principe du moindre privilège, en accordant aux utilisateurs et aux services uniquement les autorisations dont ils ont besoin pour exercer leurs fonctions.

Modèle de sécurité basé sur les ressources

Le modèle de sécurité basé sur les ressources d'IRIS comprend:

  1. Ressources: Objets sécurisés tels que les bases de données, les services, les applications et les opérations systèmes
  2. Autorisations: Différents niveaux d'accès aux ressources (lecture, écriture, utilisation)
  3. Rôles: Ensembles d'autorisations sur les ressources qui peuvent être attribués aux utilisateurs
  4. Utilisateurs: Comptes auxquels des rôles sont attribués et qui peuvent se connecter au système

Ce modèle permet aux administrateurs de sécurité de créer une structure de sécurité qui restreint l'accès en fonction des tâches et des besoins. Par exemple:

  • Les administrateurs de bases de données peuvent avoir un accès complet aux ressources de la base de données, mais un accès limité aux ressources de l'application
  • Les utilisateurs de l'application peuvent avoir accès uniquement à certaines fonctions spécifiques de l'application
  • Les comptes de service pour les intégrations peuvent avoir des autorisations restreintes adaptées à leurs besoins spécifiques

Documentation InterSystems

La mise en œuvre de la sécurité basée sur les rôles dans IRIS est bien documentée dans la documentation officielle d'InterSystems:

En tirant parti du cadre de sécurité intégré d'IRIS, les organisations peuvent créer un modèle de sécurité respectant le principe du moindre privilège, ce qui réduit considérablement le risque d'accès non autorisé ou d'augmentation des privilèges.

5.4 Cryptage des données

Les fichiers de la base de données IRIS sont cryptés à l'aide du cryptage AWS EBS au repos avec des clés KMS gérées par l'utilisateur:

kind:StorageClassapiVersion:storage.k8s.io/v1metadata:  name:iris-ssd-storageclassprovisioner:kubernetes.io/aws-ebsparameters:  type:gp3  encrypted:"true"volumeBindingMode:WaitForFirstConsumerallowVolumeExpansion:true

Le cluster EKS est configuré pour utiliser des volumes EBS chiffrés pour tout le stockage persistant, garantissant ainsi que les données inactives sont protégées par un chiffrement AES-256.

5.5 Sauvegarde et reprise après incident

Pour protéger contre la perte de données et garantir la continuité des activités de nos clients, notre architecture met en œuvre les mesures suivantes:

  1. Mise en miroir des journaux: Les journaux IRIS sont stockés sur des volumes distincts et mis en miroir
  2. Sauvegardes automatisées: Sauvegardes régulières vers des buckets S3 cryptés
  3. Réplication AZ croisée: Les données critiques sont répliquées vers une zone de disponibilité (AZ) AWS secondaire

Cette approche garantit que même en cas de panne catastrophique ou d'incident de sécurité, les données peuvent être récupérées avec un minimum de pertes.

Guide de mise en œuvre

Pour mettre en œuvre cette architecture de sécurité à plusieurs niveaux pour vos propres déploiements IRIS sur AWS, suivez ces étapes générales:

Étape 1 : Configuration de l'infrastructure AWS

  1. Créez un VPC avec des sous-réseaux privés et publics dans plusieurs zones de disponibilité
  2. Configurez des passerelles NAT pour la connectivité sortante à partir des sous-réseaux privés
  3. Créez des groupes de sécurité avec des règles d'entrée et de sortie appropriées
  4. Déployez un cluster EKS dans des sous-réseaux privés

Étape 2: Configuration des services de sécurité AWS

  1. Créez une liste de contrôle d'accès Web AWS WAF avec les ensembles de règles appropriés
  2. Configurez la distribution CloudFront avec l'association WAF
  3. Configurez AWS ALB pour Kubernetes Ingress

Étape 3 : Déployez l'IAM d'InterSystems

  1. Créez les informations secrètes Kubernetes nécessaires pour les certificats et les informations d'identification
  2. Déployez l'IAM StatefulSet à l'aide de l'opérateur IrisCluster
  3. Configurez les plugins de sécurité IAM (limitation du taux, gestion des sessions, validation des requêtes)

Étape 4 : Déploiement et sécurisation du cluster IRIS

  1. Créez une ressource personnalisée IrisCluster avec des configurations de sécurité
  2. Configurez TLS pour toutes les communications
  3. Déployez la passerelle Web avec une configuration renforcée
  4. Configurez la mise en miroir de la base de données et la sécurité ECP

Étape 5 : Mise en œuvre de la surveillance et de la journalisation

  1. Configurez la journalisation centralisée avec ElasticSearch
  2. Configurez la surveillance de la sécurité avec Datadog
  3. Mettez en œuvre des alertes pour les événements de sécurité
  4. Activez la journalisation d'audit IRIS

Surveillance et réponse aux incidents

Une architecture de sécurité robuste doit inclure des capacités de surveillance continue et de réponse aux incidents. Notre mise en œuvre comprend:

6.1 Surveillance de la sécurité

L'architecture comprend une surveillance complète à l'aide de Datadog et ElasticSearch:

  1. Analyse des journaux en temps réel: Tous les composants envoient leurs journaux à un cluster ElasticSearch centralisé
  2. Tableaux de bord de sécurité: Les tableaux de bord Datadog visualisent les mesures de sécurité et les anomalies
  3. Alertes automatisées: Des alertes sont générées en cas d'activités suspectes ou de violations de la sécurité

6.2 Réponse aux incidents

Un processus défini de réponse aux incidents garantit une réaction rapide aux événements de sécurité:

  1. Détection: Détection automatisée des incidents de sécurité grâce à la surveillance
  2. Classification: Les incidents sont classés par gravité et par type
  3. Contention: procédures visant à contenir les incidents, y compris les réponses automatisées
  4. Éradication: Mesures visant à éliminer la menace et à rétablir la sécurité
  5. Récupération: Procédures de restauration du fonctionnement normal
  6. Leçons apprises: Analyse post-incident pour améliorer le niveau de sécurité

Considérations relatives aux performances

La mise en œuvre de plusieurs niveaux de sécurité peut avoir un impact sur les performances. Notre architecture répond à ce problème grâce aux éléments suivants:

7.1 Stratégies de mise en cache

  1. Mise en cache CloudFront: Le contenu statique est mis en cache à la périphérie
  2. Mise en cache de la passerelle API: IAM implémente la mise en cache des réponses pour les points de terminaison appropriés
  3. Mise en cache de la passerelle Web: Les pages CSP sont mises en cache lorsque cela est possible

7.2 Équilibrage de charge

  1. Déploiement multizone de disponibilité (AZ): Les services sont répartis entre plusieurs zones de disponibilité
  2. Mise à l'échelle horizontale: Les composants peuvent être mis à l'échelle horizontalement en fonction de la charge
  3. Paramètres d'affinité: L'anti-affinité des pods garantit une distribution adéquate

7.3 Mesures de performance

Au cours de la mise en œuvre, nous avons observé les impacts suivants sur les performances:

  1. Latence: La latence moyenne des requêtes n'a augmenté que de 20 à 30 ms malgré toutes les niveaux de sécurité
  2. Débit: Le système peut traiter plus de 2 000 demandes par seconde avec toutes les mesures de sécurité
  3. Utilisation des ressources: Les composants de sécurité supplémentaires ont augmenté l'utilisation du processeur d'environ 15%

Ces mesures démontrent qu'une architecture de sécurité robuste peut être mise en œuvre sans dégradation significative des performances.

Conclusion

L'architecture de sécurité à plusieurs niveaux décrite dans cet article fournit une protection complète pour les déploiements InterSystems IRIS sur AWS. En mettant en œuvre des contrôles de sécurité à chaque niveau, du périmètre du réseau à la base de données, nous créons une stratégie de défense en profondeur qui réduit considérablement le risque d'attaques réussies.

Les principaux avantages de cette approche sont les suivants:

  1. Protection complète: Plusieurs niveaux fournissent une protection contre un large éventail de menaces
  2. Défense en profondeur: Si une mesure de sécurité échoue, les autres restent en place
  3. Évolutivité: l'architecture est scalable horizontalement pour gérer une charge accrue
  4. Simplicité de gestion: L'approche "infrastructure en tant que code" rend les contrôles de sécurité reproductibles et versionnables
  5. Conformité: L'architecture aide à respecter les exigences réglementaires en matière de protection des données

En tirant parti des services de sécurité AWS, d'IAM d'InterSystems et des configurations IRIS sécurisées, les organisations peuvent créer des applications sécurisées et hautement performantes tout en protégeant les données sensibles contre les menaces émergentes.

Références

  1. Documentation InterSystems: Guide de sécurité IRIS
  2. Meilleures pratiques en matière de sécurité AWS: Pilier de la sécurité AWS
  3. Sécurité Kubernetes: Guide des meilleures pratiques EKS
  4. Sécurité API OWASP: Les 10 principaux risques liés à la sécurité API
  5. Registre de conteneurs InterSystems: containers.intersystems.com
0
0 17
Article Sylvain Guilbaud · Mai 9, 2025 9m read

L'indication de requête parallèle augmente les performances de certaines requêtes sur les systèmes multiprocesseurs par le biais du traitement parallèle. L'optimiseur SQL détermine les cas où cela est bénéfique. Sur les systèmes à un seul processeur, cette indication n'a aucun effet.

Le traitement parallèle peut être géré par:

  1.  Définition de l'option auto parallel pour l'ensemble du système.
    
  2. L'utilisation du mot-clé %PARALLEL dans la clause FROM de certaines requêtes.
    

Le mot clé %PARALLEL est ignoré lorsqu'il est appliqué aux requêtes suivantes:

  1. Les requêtes INSERT, UPDATE et DELETE (cette fonctionnalité ne s'applique qu'aux requêtes SELECT)
  2. Les requêtes impliquant des fonctions ou des variables spécifiques au processus
  3. Une sous-requête corrélée à une requête englobante.
  4. Une sous-requête contenant des prédicats complexes, tels que les prédicats FOR SOME et FOR SOME %ELEMENT.

En plus des raisons mentionnées précédemment, voici quelques raisons pour lesquelles le traitement parallèle des requêtes peut être ignoré:

  • Certaines requêtes complexes ne bénéficient pas d'un traitement parallèle, même si elles semblent en bénéficier au départ.
  • Certaines configurations et paramètres de base de données ne supportent pas le traitement %PARALLEL.
  • Les dépendances et les relations au sein de la structure des données peuvent empêcher une parallélisation efficace.

Dans des scénarios suivants, %PARALLEL n'effectuera pas de traitement parallèle:

  1.  La requête inclut à la fois les clauses TOP et ORDER BY, en optimisant le temps le plus rapide pour atteindre la première ligne.
    
  2.  La requête fait référence à une vue et renvoie un identifiant de vue.
    
  3.  La requête utilise des formats de stockage personnalisés ou des tables GLOBAL TEMPORARY ainsi que des tables avec un stockage de référence global étendu.
    
  4.  La requête accède à une table avec une sécurité au niveau de la ligne.
    
  5.  Les données sont stockées dans une base de données distante.
    
  6.  La collation NLS au niveau du processus ne correspond pas à la collation NLS de tous les globaux impliqués.
    

Pour plus de détails sur les options, les considérations et les restrictions, reportez-vous à Configure Parallel Query Processing (Interystems Documentation) et Specify Optimization Hints in Queries (Configuration du traitement parallèle des requêtes (Documentation Interystems) et Spécifier les conseils d'optimisation dans les requêtes). Ce sujet a été récemment exploré dans le cadre d'une discussion au sein de la Communauté de développeurs d'InterSystems (DC), qui a inspiré cet article sur IRIS, Cache et Ensemble.

InterSystems IRIS supporte le traitement parallèle à la fois pour le SQL intégré, le SQL dynamique et le SQL dans les QueryMethods. Lorsque le mot-clé %PARALLEL est utilisé dans la clause FROM d'une requête pour suggérer un traitement parallèle. L'optimiseur SQL déterminera si la requête peut bénéficier d'un traitement parallèle et l'appliquera le cas échéant.

Pour utiliser efficacement le traitement %PARALLEL dans InterSystems IRIS, plusieurs paramètres et restrictions doivent être pris en compte, tant au niveau du système qu'au niveau de la requête, afin d'en tirer tous les avantages.

Dans le cas où vous essayez d'obtenir le traitement %PARALLEL à l'aide du traitement parallèle des requêtes à l'échelle du système et que le mode adaptatif est désactivé, vous pouvez activer le traitement parallèle des requêtes à l'échelle du système via le Portail de gestion ou $SYSTEM.SQL.Util.SetOption() Exemple

USER>w ##class(%SYSTEM.SQL.Util).GetOption("AutoParallel")
0
USER>d ##class(%SYSTEM.SQL.Util).SetOption("AutoParallel",1,.oldParVal)
 
USER>w ##class(%SYSTEM.SQL.Util).GetOption("AutoParallel")
1
USER>zw oldParVal
oldParVal=0

Autres aspects importants à prendre en compte lors de la mise en œuvre de la fonctionnalité %PARALLEL.

  •   Lorsque le [AdaptiveMode](https://docs.intersystems.com/iris20242/csp/docbook/DocBook.UI.Page.cls?KEY=RACS_AdaptiveMode) est activé, le traitement parallèle automatique est appliqué à toutes les requêtes SELECT, en les accompagnant de la mention %PARALLEL. Cependant, toutes les requêtes ne peuvent pas utiliser le traitement parallèle, car l'optimiseur SQL peut en décider autrement.
    
  •   Lorsque nous essayons d'utiliser cette fonctionnalité %PARALLEL, nous devons également prendre en compte le paramètre  [AutoParallelThreshold](https://docs.intersystems.com/iris20242/csp/docbook/Doc.View.cls?KEY=RACS_AutoParallelThreshold) (la valeur par défaut est 3200) et ce paramètre n'est pas utile dans le cas où [AutoParallel](https://docs.intersystems.com/iris20242/csp/docbook/DocBook.UI.Page.cls?KEY=RACS_AutoParallel) est désactivé.
    
  •   Le paramètre AutoParallelThreshold détermine si une requête est exécutée en parallèle, les valeurs les plus élevées réduisant les chances de traitement en parallèle. La valeur par défaut est 3200, elle peut être ajustée via $SYSTEM.SQL.Util.SetOption("AutoParallelThreshold",n,.oldval).
    
  •   Dans les environnements partagés, le traitement parallèle est utilisé pour toutes les requêtes, quel que soit le seuil, lorsque le mode adaptatif AdaptiveMode est activé.
    
  •   Lorsque le mode AdaptiveMode est activé (défini à 1) et que la fonctionnalité AutoParallel est désactivée, le Mode adaptatif remplace le paramètre AutoParallel et active le traitement parallèle.
    

Exemple: Exemple de classe avec 100 000 enregistrements remplis

 Class SQLClass.MyTest Extends (%Persistent, %Populate)
  {
    
    Property Name As %String(MAXLEN = 255);
    
    Property Age As %Integer(MAXVAL = 100, MINVAL = 1);
    
    Property Address As %String(MAXLEN = 255);
    
    Property City As %String(MAXLEN = 255);
    
    Property State As %String(MAXLEN = 255);
    
    Property Zip As %String(MAXLEN = 255);
    
    Property Country As %String(MAXLEN = 255);
    
    Property Comment As %String(MAXLEN = 255);
    
    Property Hobby As %String(MAXLEN = 255);
    
    Property JobTitle As %String(MAXLEN = 255);
    
    Property Company As %String(MAXLEN = 255);
    
    Property PhoneNumber As %String(MAXLEN = 255);
    
    Property Email As %String(MAXLEN = 255);
    
    Property Gender As %String(MAXLEN = 1);
    
    Property Ethnicity As %String(MAXLEN = 255);
    
    Property Race As %String(MAXLEN = 255);
    
    Property Religion As %String(MAXLEN = 255);
    
    Property MaritalStatus As %String(MAXLEN = 255);
    
    Property Children As %Integer(MAXVAL = 10, MINVAL = 0);
    
    Property Income As %Integer(MAXVAL = 100000, MINVAL = 0);
    
    Property Occupation As %String(MAXLEN = 255);
    
    Property Education As %String(MAXLEN = 255);
    
    Property HomePhone As %String(MAXLEN = 255);
    
    Property MobilePhone As %String(MAXLEN = 255);
    
    Property WorkPhone As %String(MAXLEN = 255);
    
    Property WorkEmail As %String(MAXLEN = 255);
    
    Property HomeEmail As %String(MAXLEN = 255);
    
    Property HomeAddress As %String(MAXLEN = 255);
    
    Property HomeCity As %String(MAXLEN = 255);
    
    Property HomeState As %String(MAXLEN = 255);
    
    Property HomeZip As %String(MAXLEN = 255);
    
    Property HomeCountry As %String(MAXLEN = 255);
    
    Property WorkAddress As %String(MAXLEN = 255);
    
    Property WorkCity As %String(MAXLEN = 255);
    
    Property WorkState As %String(MAXLEN = 255);
    
    Property WorkZip As %String(MAXLEN = 255);
    
    Property WorkCountry As %String(MAXLEN = 255);
    
    Property WorkPhoneNumber As %String(MAXLEN = 255);
    
    Property WorkMobilePhone As %String(MAXLEN = 255);
    
    Property WorkFax As %String(MAXLEN = 255);
    
    Property WorkWebsite As %String(MAXLEN = 255);
    
    Property WorkComments As %String(MAXLEN = 255);
    
    
    Index IdxAge On Age;
}

Test n° 1Exemple d'exécution sans % PARALLEL (pour afficher 10 000 enregistrements en SMP)

select * from SQLClass.MyTest where age>40
  • 3.2069 secondes
  • 10404 références globales
  • 3325407 commandes exécutées

Exemple d'exécution avec %PARALLEL(pour afficher 10 000 enregistrements dans SMP)

select * from %PARALLEL SQLClass.MyTest where age>40
  • 2.8681 secondes
  • 10404 références globales
  • 3325407 commandes exécutées

Test n° 2 :Exemple d'exécution sans % PARALLEL (pour afficher 1 enregistrement en SMP)

select COUNT(Children),MAX(Children),MIN(Children),AVG(Children) from SQLClass.MyTest where age>10
  • 0.4037 secondes
  • 46559 références globales
  • 1459936 commandes exécutées

Exemple d'exécution avec %PARALLEL (pour afficher 1 enregistrement en SMP)

select COUNT(Children),MAX(Children),MIN(Children),AVG(Children) from %PARALLEL SQLClass.MyTest where age>10
  • 0.0845 secondes
  • 46560 références globales
  • 1460418 commandes exécutées

Exemple avec SQL intégré

ClassMethod embeddedSQL() As %Status
{
    // w ##Class(SQLClass.MyTest).embeddedSQL()
    Set sc = $$$OK
    DO ClearBuffers^|"%SYS"|GLOBUFF()
    set stime=$p($zts,",",2)
    &sql(select COUNT(Children),MAX(Children),MIN(Children),AVG(Children) from SQLClass.MyTest where age>10)
    w:'SQLCODE "Without %Parallel : ",($p($zts,",",2)-stime),!
    DO ClearBuffers^|"%SYS"|GLOBUFF()
    set stime=$p($zts,",",2)
    &sql(select COUNT(Children),MAX(Children),MIN(Children),AVG(Children) from %PARALLEL SQLClass.MyTest where age>10)
    w:'SQLCODE "With %Parallel : ",($p($zts,",",2)-stime),!
    Return sc
}

Résultats (SQL intégré) : USER> D ##Class(SQLClass.MyTest).embeddedSQL() 5466 blocs supprimés Sans %Parallel : .355737 5217 blocs supprimés Avec %Parallel : .3407056

USER>

Exemple avec SQL dynamique

ClassMethod dynamicSQL() As %Status
{
     // w ##Class(SQLClass.MyTest).dynamicSQL()
    Set sc = $$$OK
    DO ClearBuffers^|"%SYS"|GLOBUFF()
    set stime=$p($zts,",",2), recCnt=0
    Set rs=##class(%ResultSet).%New()
    Set sc=rs.Prepare("select COUNT(Children),MAX(Children),MIN(Children),AVG(Children) from SQLClass.MyTest where age>10")
    Set sc=rs.Execute()
    While(rs.Next()) {
	 	w "COUNT(Children) : ",rs.GetData(1),"; MAX(Children) : ",rs.GetData(2),"; MIN(Children) : ",rs.GetData(3),"; AVG(Children) : ",rs.GetData(4),!
    }
    w "Without %Parallel : ",($p($zts,",",2)-stime),!!!
    DO ClearBuffers^|"%SYS"|GLOBUFF()
    set stime=$p($zts,",",2), recCnt=0
    Set sc=rs.Prepare("select COUNT(Children),MAX(Children),MIN(Children),AVG(Children) from SQLClass.MyTest where age>10")
    Set sc=rs.Execute()
    While(rs.Next()) {
	 	w "COUNT(Children) : ",rs.GetData(1),"; MAX(Children) : ",rs.GetData(2),"; MIN(Children) : ",rs.GetData(3),"; AVG(Children) : ",rs.GetData(4),!
	}
    w "With %Parallel : ",($p($zts,",",2)-stime),!
    Return sc
}

Résultats (SQL dynamique): USER>d ##Class(SQLClass.MyTest).dynamicSQL() 22163 blocs supprimés NOMBRE(Enfants) : 89908; MAX(Enfants) : 10; MIN(Enfants) : 0; AVG(Enfants) : 5.021989144458780086 Sans %Parallel : .4036913

5721 blocs supprimés NOMBRE(Enfants) : 89908; MAX(Enfants) : 10; MIN(Enfants) : 0; AVG(Enfants) : 5.021989144458780086 Avec %Parallel : .3693442

0
0 37
Article Lorenzo Scalese · Jan 6, 2025 6m read

Salut la Communauté,

image
Dans cet article, je présenterai mon application iris-HL7v2Gen.

IRIS-HL7v2Gen est une application CSP qui facilite la génération dynamique de messages de test HL7. Ce processus est essentiel pour tester, déboguer et intégrer les systèmes de données de soins de santé. L'application permet aux utilisateurs de générer une grande variété de types de messages HL7, de valider leur structure par rapport aux spécifications HL7, d'explorer la hiérarchie des messages et de transmettre les messages par TCP/IP aux systèmes de production. Ces fonctionnalités sont particulièrement utiles dans les contextes où la conformité aux normes HL7 est obligatoire pour assurer l'interopérabilité entre différents organismes ou systèmes de soins de santé.

Fonctionnalités de l'application

  • Génération Dynamique de Messages HL7: Création instantanée de messages HL7 pour une gamme de types de messages, facilitant ainsi les tests complets.
  • Exploration de la structure des messages: Visualisation de la structure des messages générés sur la base des spécifications HL7.
  • Visualisation des jeux de valeurs: Visualisation des jeux de valeurs codées prédéfinis pour des champs spécifiques.
  • Validation des messages: Validation des messages par rapport aux normes HL7 pour garantir la conformité.
  • Communication TCP/IP: Transmission facile de messages à la production à l'aide de paramètres TCP/IP.
  • Prise en charge d'un grand nombre de types de messages: Prise en charge de 184 types de messages HL7, garantissant la polyvalence pour les différents besoins d'intégration des soins de santé.
  • ClassMethod: Génération d'un message de test par l'invocation d'une méthode de classe
  • Version prise en charge: Actuellement, la version 2.5 de HL7 est prise en charge
0
0 55
Article Iryna Mykhailova · Avr 6, 2024 2m read

Rubrique FAQ InterSystems

La page de gestion de Web/CSP Gateway est généralement configurée de manière à ne pas être accessible à partir des machines clientes.

Pour y accéder depuis n'importe quel client, procédez comme suit :

0
0 94
Article Pierre LaFay · Fév 25, 2024 13m read

La classe %CSP.Login est la classe utilitaire fournie par InterSystems IRIS pour créer des pages de connexion personnalisées. Si vous souhaitez contrôler l'interface utilisateur d'authentification de votre application IRIS, vous devez étendre %CSP.Login et surcharger certaines méthodes en fonction de vos besoins. Cet article va détailler ces méthodes et ce que vous pouvez faire avec elles. En outre, vous obtiendrez une explication du mécanisme d'authentification déléguée fourni par la routine ZAUTHENTICATE.mac. Enfin, vous serez en mesure de créer une logique d'authentification personnalisée,

0
0 64
Question Pierre LaFay · Fév 13, 2024

Bonjour à tous,

Nous développons une application avec FrontEnd (angular) et BackEnd (objectscript Iris), nous utilisons l'identification intégrée grâce à la route /login fournie par %CSP.REST. Nous n'utilisons pas IAM, nous attaquons l'API directement.

Nous avons besoin de générer un traitement suite à un login qu'il soit réussi ou non (enregistrement dans une log applicative).

Nous avons essayé de créer une méthode Login dans notre classe d'API, avec un appel à super(), mais cela ne fonctionne pas car notre méthode n'est pas appelée par la route, qui appele Login de %CSP.Rest.

0
0 52
Question Jean-Charles Cano · Nov 23, 2023

Bonjour,

Je souhaite accéder à la Web Gateway. N'ayant pas fait l'installation d'Iris sur la machine je ne connais pas le compte autorisé à y accéder.

J'ai donc ajouté les propriétés username et password dans le fichier CSP.ini dans la section [SYSTEM] comme indiqué dans cette doc : 

https://docs.intersystems.com/irislatest/csp/docbook/DocBook.UI.Page.cl…

Puis j'ai relancé le server web à l'aide de la commande : do ##class(Config.Startup).RestartWebServer()

Je me suis ensuite rendu sur la page 

http://localhost:52773/csp/bin/Systems/Module.cxw
2
0 106
Article Guillaume Rongier · Nov 17, 2023 3m read

Rubrique Questions fréquentes (FAQ) d'InterSystems

Pour les routines (*.mac)

Vous pouvez masquer la source en exportant/important uniquement le fichier *.obj généré après la compilation du programme source.

L'exemple d'exécution de la commande spécifie EX1Sample.obj et EX2Sample.obj, qui sont générés par la compilation de EX1Sample.mac et EX2Sample.mac, comme cibles d'exportation et les exporte dans le deuxième fichier argument.

Après avoir changé d'espace de noms, j'utilise le fichier XML exporté pour effectuer l'importation.

0
0 73
Question Sandeep K C · Août 24, 2023

Salut,

Dans une application CSP de Caché, j'ai activé les jours d'expiration du mot de passe à certains jours dans Système > Gestion de la sécurité > Paramètres de sécurité de niveau système. Lorsque le mot de passe expire pour les utilisateurs et qu'ils tentent de se connecter, la page de connexion passe à la page de modification du mot de passe du cache standard.

Puis-je afficher ma page personnalisée au lieu de la page de modification du mot de passe standard de Caché ?

2
0 69
Question Sandeep K C · Août 24, 2023

Salut,

Pour la connexion à l'application CSP, j'affiche une page de connexion personnalisée qui est rendue à partir de la sous-classe CSS.CSP.Login qui hérite de %CSP.Login, et j'ai également IBA.CSP.Page qui étend %CSP.Page en surchargeant OnPreHTTP(). Cette configuration fonctionne parfaitement pour une connexion normale.

0
0 68
Article Sylvain Guilbaud · Août 10, 2023 1m read

Rubrique FAQ InterSystems

Vous pouvez définir des pages d'erreur individuelles en fonction des différents types de messages d'erreur ou de réponses système de la passerelle Web :

  • erreur de serveur 
  • serveur occupé
  • serveur indisponible
  • délai d'attente du serveur
  • connexion fermée

Les paramètres sont définis sur l'écran Gestion de passerelle Web ([Portail d'Administration] > [Administration système] > [Configuration] > [Gestion de passerelle Web] > [Configuration] > [Default Parameters]).

Dans la section "Error Pages" du menu "Default Parameters", indiquez le nom de fichier de la page html à afficher ou l'URL vers laquelle rediriger la réponse lorsqu'une erreur se produit.

  

1
0 75
InterSystems officiel Robert Bira · Mai 10, 2022

Ce mois, j'annonce la sortie de la version 1.8.0 de l'extension VS Code qui contient les améliorations et corrections de bogues suivantes.

La grande nouveauté est la prise en charge des fichiers de projet côté serveur, comme certains d'entre vous se souviendront de Studio. Si vous travaillez côté client, VS Code possède déjà d'excellentes fonctionnalités de gestion de projet. Vous pouvez simplement utiliser un dossier en tant que projet ou utiliser des multi-root workspaces. Mais si vous travaillez côté serveur, vous apprécierez peut-être de meilleures capacités de gestion des artefacts, et c'est de cela qu'il s'agit. Pour en savoir plus, consultez ce nouveau chapitre Projects de la documentation.

Changelog pour 1.8.0

  • Améliorations
    • Ajout de la prise en charge des projets côté serveur (#851)
    • Implémenter le changement de nom et la suppression du dossier isfs (#923, #922)
    • Prise en charge de l'indicateur "mapped" pour les isfs et les filtres d'exportation, pour exclure les packages mappés à partir d'autres bases de données (#931)

Le changelog complet pour toutes les versions est ici.

Comme toujours, si vous avez déjà installé l'extension, VS Code devrait automatiquement mettre à jour votre extension. Si vous êtes un nouvel utilisateur, suivez ces instructions pour commencer.

0
0 72