Le Cloud Computing est un paradigme des technologies de l'information qui permet un accès omniprésent à des pools partagés de ressources système configurables et de services de niveau supérieur qui peuvent être rapidement mis à disposition avec un effort de gestion minimal, souvent via Internet.
Cette version met l'accent sur la fiabilité des mises à niveau, l'extension de la sécurité et l'amélioration du support pour plusieurs services cloud InterSystems. Avec cette version, toutes les offres majeures, notamment FHIR Server, InterSystems Data Fabric Studio (IDS), IDS avec Supply Chain et IRIS Managed Services, prennent désormais en charge la sécurité avancée, offrant ainsi une sécurité unifiée et renforcée.
Nouvelles fonctionnalités et améliorations
Salut tout le monde! Ayant récemment rejoint InterSystems, je me suis rendu compte que, même en ayant la version communautaire de la Community Edition totalement gratuite et géniale, la manière d'y accéder n'était pas très claire. J'ai donc décidé de rédiger un guide présentant toutes les différentes façons d'accéder à la version communautaire de la Community Edition d'InterSystems IRIS:
L'utilisation d'une instance conteneurisée de la Community Edition est l'approche recommandée pour les personnes qui découvrent le développement sur InterSystems IRIS. À mon avis, c'est aussi la plus simple. La Community Edition d'InterSystems IRIS est disponible sur DockerHub; si vous avez un compte SSO InterSystems, vous pouvez également la trouver dans le registre de conteneurscan also find it in the InterSystems Container Registry.
Quel que soit le cas, vous devrez extraire l'image de votre choix à l'aide de l'interface CLI Docker:
docker pull intersystems/iris-community:latest-em
// or
docker pull containers.intersystems.com/intersystems/iris-community:latest-emEnsuite, vous devrez démarrer le conteneur: Afin d'interagir avec IRIS en dehors du conteneur (par exemple, pour utiliser le portail de gestion), vous devrez publier certains ports. La commande suivante exécutera le conteneur IRIS Community Edition avec les ports du superserveur et du serveur web publiés ; notez que vous ne pouvez rien avoir d'autre en cours d'exécution qui dépende des ports 1972 ou 52773!
docker run --name iris -d --publish 1972:1972 --publish 52773:52773 intersystems/iris-community:latest-emVous souhaitez peut-être éviter complètement le problème d'avoir à gérer une installation locale; et si tel est le cas, vous pouvez vous lancer avec un déploiement cloud de la Community Edition d'InterSystems IRIS. Tous les principaux fournisseurs de cloud sont pris en charge. Consultez notre page Cloud Partners page pour plus d'information. Dans cet exemple, nous allons nous concentrer sur le déploiement sur AWS.
Commencez par rechercher la Community Edition d'InterSystems IRIS sur AWS Marketplace:
Vous pouvez cliquer sur "View purchase options" (Afficher les options d'achat) et vous connecter à votre compte pour afficher la page d'abonnement:
En faisant défiler vers le bas, vous pouvez cliquer sur “Subscribe” (s'abonner), remplir l'information requise, puis cliquer sur “Deploy” (déployer) pour déployer la Community Edition d'InterSystems IRIS en tant que nœud cloud! Consultez notre documentation ici déploiement d'InterSystems IRIS dans le cloud pour plus de d'information.
Si vous préférez travailler avec InterSystems IRIS installé directement sur votre machine et que vous ne souhaitez pas utiliser de conteneurs, vous pouvez télécharger un kit d'installation pour votre système à partir du service InterSystems Evaluation Service. Pour télécharger un kit d'installation, vous devez avoir un identifiant SSO InterSystems. Bonne nouvelle: si vous avez un compte sur la Communauté de développeurs, vous en avez déjà un! Sinon, vous pouvez cliquer sur "Créer un nouveau compte" et suivre les étapes indiquées:
Une fois connecté, la page suivante devrait s'afficher. Cliquez sur "Télécharger la version Community Edition" pour commencer le téléchargement du kit d'installation:
Vous serez invité à fournir certaines information concernant la version exacte d'InterSystems IRIS dont vous avez besoin et la plate-forme sur laquelle vous allez l'installer:
Dans la plupart des cas, vous devrez sélectionner « InterSystems IRIS Community » et la version la plus récente disponible pour votre plateforme. Suivez les instructions d'installation fournies dans la documentation spécifique à votre plateforme, et le tour est joué!
Version 2025.1.0.1.24372U.f00326d.
Cette version offre une prise en charge Azure étendue pour InterSystems Data Fabric Studio, une flexibilité d’abonnement améliorée, des mises à jour majeures des modules et de multiples améliorations de la mise en réseau, de la sécurité et de la réactivité des API.
Nouvelles fonctionnalités et améliorations
Référence : Build 2025.1.0.1.24372U.25e14d55
Cette version apporte des améliorations significatives à la sécurité, aux capacités d'analyse et à l'expérience utilisateur, ainsi que des améliorations opérationnelles majeures visant à réduire les temps d'arrêt et à améliorer la fiabilité.
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:
À 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:.jpeg)
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:
Cette architecture sépare les problèmes et fournit plusieurs niveaux de redondance:
Chaque composant joue un rôle spécifique dans la pile de sécurité:
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.
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:
/app/, /csp/broker/, /api/, and /csp/appdataEn 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é:
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-ForX-Real-IPCette 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.
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:
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: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:
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.
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.
.png)
.png)
.png)
{ "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:
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:
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..png)
{ "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:
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:
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-secretCette 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:
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:
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:
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-secretNotre implémentation TLS garantit:
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-1cNotre déploiement IKO comprend plusieurs fonctionnalités de sécurité essentielles:
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:
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:
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:
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:trueLe 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:
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
Étape 2: Configuration des services de sécurité AWS
Étape 3 : Déployez l'IAM d'InterSystems
Étape 4 : Déploiement et sécurisation du cluster IRIS
Étape 5 : Mise en œuvre de la surveillance et de la journalisation
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:
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é:
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
7.2 Équilibrage de charge
7.3 Mesures de performance
Au cours de la mise en œuvre, nous avons observé les impacts suivants sur les performances:
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:
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
Le déplacement d'InterSystems IRIS et d'InterSystems IRIS for Health d'un environnement sur site vers le cloud offre de nombreux avantages aux Fournisseurs d'applications et de solutions. Ces avantages comprennent notamment la simplification des opérations, l'accès à des ressources flexibles et une résilience accrue. Les entreprises n'ont plus à se soucier des contraintes physiques et des dépenses liées à la maintenance d'une infrastructure sur site, telles que les besoins en énergie et en espace, ainsi que le coût élevé du matériel informatique.
.png)
L'un des avantages les plus convaincants est la possibilité d'accélérer la vitesse de commercialisation. En supprimant la charge liée à la maintenance de l'infrastructure, les environnements cloud permettent des cycles de développement et de déploiement plus rapides, ce qui permet aux entreprises de réagir rapidement aux demandes et aux opportunités du marché. Les coûts opérationnels sont également réduits, car les entreprises peuvent sadapter leurs ressources à la hausse ou à la baisse en fonction de leurs besoins réels, ce qui se traduit par une utilisation plus efficace du capital. De plus, la migration vers le cloud peut contribuer à réduire l'empreinte carbone en optimisant la consommation d'énergie grâce à une infrastructure cloud partagée.
Le déplacement vers le cloud peut impliquer des changements importants. Les entreprises peuvent bénéficier d'une orientation plus opérationnelle, en gérant et en optimisant en permanence les ressources cloud. Cette évolution peut nécessiter des changements dans les modèles commerciaux, une redéfinition des marges et des stratégies d'expansion ou de réduction des activités. Bien qu'ils nécessitent des investissements plus importants, ces changements peuvent améliorer la flexibilité et l'avantage compétitif sur le marché.
Lorsqu'elles envisagent la migration vers le cloud la plus simple, les entreprises doivent choisir un ou plusieurs services (AWS, Azure, Google ou autre) pour déplacer une application existante sur site vers l'un des clouds publics. Elles sont alors confrontées à un choix architectural important : migrer entièrement vers le cloud ou créer un cluster hybride sur site et dans le cloud. InterSystems IRIS et InterSystems IRIS for Health prennent tous deux entièrement en charge ces deux options. Un cluster hybride miroite l'instance sur site vers le cloud de manière asynchrone. Cette alternative peut être utile dans des situations telles que celles où l'OLTP continue de fonctionner sur site, mais où l'instance cloud fournit une prise en charge pour l'analyse, la création de rapports et d'autres opérations en lecture seule.
Chaque choix architectural pour la migration vers le cloud a ses avantages et ses limites, il est donc essentiel pour les entreprises d'évaluer leurs besoins et leurs objectifs spécifiques lors de la planification d'une stratégie cloud. La première étape consiste à choisir entre une migration complète vers le cloud ou une configuration hybride.
| Choix migratoire | Nombre de déploiements InterSystems IRIS après la migration | Caractéristiques |
| Lift & Shift: migration complète vers le cloud | 1 | Configuration sur site locale transférée vers une architecture cloud |
| Cluster hybride : sur site plus copie miroir dans le cloud ("cluster étendu") | 2 | Cluster sur site mis en miroir vers une copie cloud en lecture seule mise à jour de manière asynchrone |
Le choix Lift & Shift permet de profiter des avantages du cloud tout en conservant la propriété d'une seule copie d'InterSystems IRIS.
Le choix Hybrid combine la stabilité et la familiarité des systèmes sur site avec la flexibilité et l'évolutivité du cloud.
Consultez notre documentation en ligne pour plus d'informations sur la mise en miroir Mirroring.
Bien que la migration ne nécessite aucune modification de votre méthode de mutualisation, le cloud offre de puissantes options d'évolutivité et de facturation. Pour cette raison, vous souhaiterez peut-être réévaluer votre modèle de mutualisation. Pour toutes nos offres, lors du déploiement d'applications InterSystems IRIS dans le cloud, les entreprises peuvent choisir entre les architectures suivantes pour plusieurs utilisateurs:
Chaque architecture présente des avantages et des inconvénients distincts. Cela est particulièrement important pour les fournisseurs d'applications et de solutions qui ont développé des solutions à l'aide de la technologie InterSystems IRIS, que ce soit pour un grand nombre d'utilisateurs, dans le cadre d'une expansion majeure ou pour l'hébergement de données sensibles ou réglementées.
.png)
Plusieurs approches sont disponibles pour migrer votre solution InterSystems IRIS de vos sites vers le service cloud de votre choix.
Les deux méthodes les plus courantes sont décrites ci-dessous. Elles commencent toutes deux par la même étape, qui consiste à miroiter un déploiement existant vers le cloud, mais elles divergent ensuite.
Les méthodes du miroir et du lift-and-shift commencent toutes deux par la copie de votre InterSystems IRIS existant depuis votre environnement sur site vers une plateforme cloud. Une fois la copie cloud synchronisée avec l'instance sur site, vous choisissez définitivement où se termine le chemin de migration:
La mise en miroir de votre instance InterSystems IRIS locale existante vers le cloud est le moyen le plus courant, le plus résilient et le plus simple de migrer votre déploiement sur site. Pour plus d'informations, consultez le Guide de migration du serveur Server Migration Guide dans notre documentation en ligne.
Plus d'articles sur le sujet:
Si vous cherchez un cas d'utilisation pour une Document Database, j'ai compris que mon cas préféré, très simple, est la possibilité d'interroger un paquet de JSON, juste à côté de mes autres données avec sql sans vraiment faire grand-chose. C'est un rêve réalisé à partir de la puissante plateforme de données multi-modèles d'InterSystems, et montré ici dans un simple carnet pour visualiser mes données de localisation géographique que mon Rivian R1S émet pour DeezWatts ( Une aventure de données Rivian ).
Voici donc l'approche en 2 étapes, à savoir l'ingestion à et la visualisation de InterSystems Cloud Document, à l'aide du pilote document JDBC.
Pour commencer, j'ai lancé un petit déploiement de Cloud Document sur le portail InterSystems Cloud Services Portal, avec un listener activé.
J'ai téléchargé le certificat ssl, et j'ai récupéré les drivers pour JDBC ainsi que le pilote de document qui l'accompagne.
Pour l'ingestion, j'ai voulu comprendre comment extraire un document JSON du système de fichiers et le faire persister en tant que collection dans la base de données de documents via le listener, pour cela j'ai écrit une application Java autonome. Cette approche était plus utilitaire, car tout ce qui était amusant se passait dans le carnet une fois que les données y étaient placées.
Ce qui précède est assez proche de JAVA trash, mais cela fonctionne, nous pouvons voir la collection dans le navigateur de collection lors du déploiement.
Cela demande un peu d'installation de Databricks, mais cela vaut la peine de travailler avec pyspark la partie amusante.
J'ai ajouté les deux pilotes InterSystems au cluster, et j'ai placé le certificat dans le script d'initialisation du cluster import_cloudsql_certficiate.sh afin qu'il soit ajouté au keystore.
Pour être complet, le cluster utilise Databricks 16, Spark 3.5.0 et Scala 2.12
Nous devrions donc être prêts à exécuter une tâche PySpark et à tracer l'endroit où mon fouet a été dans le sous-ensemble de données que je traîne.
Nous utilisons l'ensemble de données de base géo geopandas and geodatasets pour une approche directe de la représentation graphique.
import geopandas as gpd
import geodatasets
from shapely.geometry import PolygonIl faut un peu de temps pour s'y habituer, mais voici la requête adressée à InterSystems Cloud Document en utilisant la syntaxe des chemins JSON et JSON_TABLE.
dbtablequery = f"(SELECT TOP 1000 lat,longitude FROM JSON_TABLE(deezwatts2 FORMAT COLLECTION, '$' COLUMNS (lat VARCHAR(20) path '$.whip2.data.vehicleState.gnssLocation.latitude', longitude VARCHAR(20) path '$.whip2.data.vehicleState.gnssLocation.longitude' ))) AS temp_table;"
J'ai réussi à trouver un site qui facilite grandement la création du chemin json path @ jsonpath.com.
Ensuite, nous établissons la connexion avec le déploiement de la base de données documentaire IRIS Document Database et nous lisons les données dans un cadre de données.
# Read data from InterSystems Lecture des données de la base de données documentaire InterSystems Document Database via la requête ci-dessus
df = (spark.read.format("jdbc") \
.option("url", "jdbc:IRIS://k8s-05868f04-a88b7ecb-5c5e41660d-404345a22ba1370c.elb.us-east-1.amazonaws.com:443/USER") \
.option("jars", "/Volumes/cloudsql/iris/irisvolume/intersystems-document-1.0.1.jar") \
.option("driver", "com.intersystems.jdbc.IRISDriver") \
.option("dbtable", dbtablequery) \
.option("sql", "SELECT * FROM temp_table;") \
.option("user", "SQLAdmin") \
.option("password", "REDACTED") \
.option("connection security level","10") \
.option("sslConnection","true") \
.load())
Ensuite, nous prenons une carte disponible à partir de jeux de données géographiques, le jeu sdoh est parfait pour une utilisation générique des États-Unis.
# La carte sdoh est fantastique grâce aux boîtes de délimitation
michigan = gpd.read_file(geodatasets.get_path("geoda.us_sdoh"))
gdf = gpd.GeoDataFrame(
df.toPandas(),
geometry=gpd.points_from_xy(df.toPandas()['longitude'].astype(float), df.toPandas()['lat'].astype(float)),
crs=michigan.crs #"EPSG:4326"
)
Maintenant, la partie la plus intéressante, nous voulons zoomer sur l'endroit où nous voulons placer les points de géolocalisation de l'endroit où le R1S a roulé, pour cela nous avons besoin d'une boîte de délimitation pour l'état du Michigan.
J'ai utilisé un outil très astucieux de Keene pour dessiner la boîte de délimitation de la géo clôture et cela me donne le tableau de coordonnées!
Maintenant le tableau de coordonnées de la boîte de délimitation est en notre possession, il nous faut l'insérer dans un objet Polygone.
polygon = Polygon([
(
-87.286377,
45.9664245
),
(
-81.6503906,
45.8134865
),
(
-82.3864746,
42.1063737
),
(
-84.7814941,
41.3520721
),
(
-87.253418,
42.5045029
),
(
-87.5610352,
45.8823607
)
])
Maintenant, traçons la piste du Rivian R1S! Il s'agit d'environ 10 000 enregistrements (j'ai utilisé l'instruction top ci-dessus pour limiter les résultats)
ax = michigan.clip(polygon).plot(color="lightblue", alpha=0.5,linewidth=0.8, edgecolor='gray')
ax.axis('off')
ax.annotate("Data: Rivian R1S Telemetry Data via InterSystems Document Database", xy=(0.01, .085), xycoords='figure fraction', fontsize=14, color='#555555')
gdf.plot(ax=ax, color="red", markersize=1.50, alpha=0.5, figsize=(200,200))
Et voilà, nous l'avons... Détroit, Traverse City, Silver Lake Sand Dunes, Holland, Mullet Lake, Interlachen... Le Michigan à l'état pur, à la Rivian.
Vous ne le réalisez peut-être pas, mais votre compte de connexion InterSystems peut être utilisé pour accéder à un très large éventail de services InterSystems pour vous aider à apprendre et à utiliser Intersystems IRIS et d'autres technologies InterSystems plus efficacement. Poursuivez votre lecture pour en savoir plus sur la manière de découvrir de nouvelles connaissances techniques et de nouveaux outils grâce à votre compte de connexion InterSystems. Après votre lecture, veuillez participer au sondage en bas de page, afin que nous puissions voir dans quelle mesure cet article vous a été utile!
.png)
Le compte de connexion InterSystems est utilisé pour accéder à divers services en ligne destinés aux clients potentiels, aux partenaires et aux utilisateurs d'InterSystems. Il s'agit d'un ensemble unique d'informations d'identification utilisées dans plus de 15 applications externes. Certaines applications (comme WRC ou iService) nécessitent une activation spécifique pour que l'accès soit accordé par le compte. Il est probable qu'il existe des ressources qui vous aideront mais dont vous ne connaissiez pas l'existence - assurez-vous de lire toutes les options et d'essayer un nouvel outil pour vous aider à améliorer votre niveau technique!!
Vous pouvez consulter tous les services disponibles avec votre compte de connexion InterSystems en visitant le Catalogue d'applications d'InterSystems, situé à l'adresse suivante: https://Login.InterSystems.com. Ce catalogue ne répertorie que les applications ou services auxquels vous avez actuellement l'accès. Il se souvient de vos applications les plus fréquemment utilisées et les place en tête de liste pour vous faciliter la tâche.
.png)
N'oubliez pas de marquer la page d'un signet pour accéder facilement à tous ces outils dans la boîte à outils de votre compte de connexion InterSystems!
Il est maintenant temps d'entrer dans les détails des applications individuelles et de voir comment elles peuvent vous aider en tant que développeur travaillant avec les technologies d'InterSystems! Lisez la suite et essayez de trouver une nouvelle application à utiliser pour la première fois afin d'améliorer votre efficacité et vos compétences en tant que développeur....
.png)
Getting Started (Pour Commencer) - gettingstarted.intersystems.com .png)
Apprentissage en ligne - learning.intersystems.com.png)
Documentation - docs.intersystems.com
.png)
Évaluation - evaluation.intersystems.com.png)
Communauté de développeurs - community.intersystems.com.png)
Idées InterSystems - ideas.intersystems.com.png)
Les Masters Mondiaux - globalmasters.intersystems.com.png)
Open Exchange - openexchange.intersystems.com .png)
WRC - wrc.intersystems.com.png)
iService - iservice.intersystems.com.png)
ICR - containers.intersystems.com.png)
Répertoire de partenaires - partner.intersystems.com .png)
CCR - ccr.intersystems.com .png)
Connexion Client - client.intersystems.com .png)
Commande en ligne - store.intersystems.comVoici quelques autres informations utiles sur les comptes de connexion InterSystems...
Les utilisateurs peuvent créer leur propre compte en cliquant sur "Créer un compte" sur n'importe quelle application publique d'InterSystems, y compris:
Par ailleurs, le FRC (First Response Center) d'InterSystems créera un compte de connexion pour les utilisateurs supportés la première fois qu'ils auront besoin d'accéder au Worldwide Response Center (WRC) ou à iService (ou les utilisateurs supportés peuvent également créer des comptes pour leurs collègues).
Avant d'utiliser un compte, l'utilisateur doit accepter les conditions générales, soit au cours de la procédure d'auto-enregistrement, soit lors de la première connexion.
.png)
Certaines applications permettent de se connecter avec Google ou GitHub:
Il s'agit du même compte de connexion InterSystems, mais avec une authentification par Google ou GitHub.
Si vous allez à https://Login.InterSystems.com et que vous vous authentifiez, vous pourrez accéder à la rubrique Options > Profil et apporter des modifications de base à votre compte. L'adresse électronique peut être modifiée via Options > Change Email.
Les problèmes liés aux comptes de connexion InterSystems doivent être adressés à Support@InterSystems.com. Veuillez inclure:
L'accès à un stockage cloud Azure pour charger/télécharger des blobs est assez simple à l'aide des méthodes API de classe %Net.Cloud.Storage.Client désignées ou des adaptateurs entrants/sortants EnsLib.CloudStorage.*.
Notez que vous devez avoir le serveur de %JavaServer External Language opérationnel pour utiliser l'API ou les adaptateurs de stockage cloud, car ils utilisent tous deux le framework PEX à l'aide du serveur Java.
Voici un bref résumé :
L'accès à Azure Blob Storage s'effectue à l'aide d'une chaîne de connexion qui ressemble à celle-ci :
IrisFirebase - FCM
Bonjour la communauté!
Après avoir lancé mon application dans l'OpenExchange (IrisFirebase avec la fonctionnalité permettant d'utiliser la base de données en temps réel de Firebase), j'ai remarqué d'autres fonctionnalités intéressantes de Firebase que nous pourrions utiliser. C'est pourquoi, en vérifiant les possibilités que Firebase nous apporte, j'ai décidé d'ajouter une nouvelle fonctionnalité au FCM d'IrisFirebase !!! (Firebase Cloud Messaging).
Comment?? Ne savez-vous pas quelle est la clé de Firebase Cloud Messaging? Ne vous inquiétez pas! Je vais vous l'expliquer tout de suite.
Firebase Cloud Messaging. “Explication”:
Firebase Cloud Messaging (FCM) est un service fourni par Google. Il permet aux développeurs d'envoyer des notifications et des messages aux appareils des utilisateurs, tels que les smartphones, les tablettes ou les ordinateurs.
Nous avons un dicton en Espagne : "Una imagen vale más que mil palabras" (une image vaut mille mots). Voici donc un exemple pour vous:
Comme vous pouvez le voir dans les captures d'écran, vous pouvez envoyer des messages avec un titre, un corps et une image personnalisés. Mais il y a une autre chose fascinante que je souhaite vous montrer.
Oui, je sais ce que vous pensez en ce moment... "Hé, ça a l'air génial, mais ça doit être assez cher, surtout pour une personne aussi fragile que moi".Alors, c'est la meilleure partie! C'est totalement gratuit!! Jetez un œil à la preuve ci-dessous:
https://firebase.google.com/products/cloud-messaging
Souhaitez-vous savoir de quelle manière vous pouvez envoyer des messages à vos applications, pages web, etc…? Quelle chance!!! Pourquoi? Car je vais vous expliquer comment le faire de manière très simple. Préparez vos timbres et enveloppes numériques car nous allons "envoyer” un tas de "lettres". Allons-y!
Si vous avez examiné mon précédent article expliquant comment utiliser IrisFirebase, vous devriez avoir une App déjà configurée dans Firebase avec une instance d'IrisFirebase en cours d'exécution. Au cas où vous ne l'auriez pas lu, veuillez suivre les étapes, 1, 2, 4, 5 et 6 de l'article ci-dessous:
Ok, si vous avez suivi toutes les étapes correctement, vous devriez avoir une instance d'IrisFirebase en cours d'exécution, alors continuons.
Pour être capable d'envoyer des messages, vous devez d'abord configurer FCM dans votre application Firebase.
Saisissez votre console Firebase et sélectionnez votre projet (dans mon cas, il s'agit de IrisFirebaseExample):
Appuyez ensuite sur le bouton Tous les produits:
Recherchez le produit "Cloud Messaging”:
Vous devez maintenant ajouter une ou plusieurs applications suivant que vous développez une application pour Android uniquement ou pour plusieurs plateformes différentes. (Dans mon cas, j'ai opté pour Android):
(Si vous prévoyez d'envoyer des messages à iOS, vous devez avoir un compte développeur Apple payant car il faut générer un certificat).
Remplissez les champs obligatoires avec les renseignements sur votre App/web (le champ SHA-1 est facultatif):
Après quelques secondes, un écran vous demandant de télécharger le fichier de configuration apparaîtra. Cliquez sur " Download google-service.json " et gardez-le en sécurité car il est crucial pour votre travail. (Vous devrez le copier à la racine du projet de votre application plus tard). Après avoir sauvegardé le fichier, cliquez sur le bouton Next.
L'étape suivante explique comment ajouter le SDK Firebase à votre application.
Cette étape est différente si vous créez une application avec Kotlin, Groovy, Flutter, etc. Dans mon cas, j'ai utilisé Flutter, et la façon la plus simple de le faire est d'installer le CLI de Firebase:
https://firebase.google.com/docs/android/setup
Je n'expliquerai pas ces étapes car elles dépassent le cadre de ce tutoriel. Cependant, n'hésitez pas à me poser des questions dans les commentaires.
Alors, continuons en appuyant sur le bouton "Suivant".
À ce stade, nous avons terminé le côté console Firebase. Félicitations, vous avez passé la partie ennuyeuse!!!
Si vous avez configuré l'application précédente dans IrisFirebase avec Firebase RealTime Database, vous pouvez l'utiliser avec FCM. Si vous n'avez pas cette application, vous pouvez la configurer en lançant la méthode ConfigApp de la classe Firebase.Helper.cls. Vous trouverez un exemple de la manière de procéder dans la classe Test.TestFCM.cls:
ClassMethod init()
{
Do##class(Firebase.Helper).ConfigApp("appNotas",””,"irisfirebaseexample.json")
}
N'oubliez pas d'utiliser vos paramètres privés (le deuxième paramètre URL n'est obligatoire que pour la base de données en temps réel ; il ne s'applique pas au FCM, vous pouvez donc l'omettre ou l'envoyer vide.
C'est très bien ! Nous avons maintenant tous les systèmes configurés : notre instance IrisFirebase avec FCM et notre App ou Web avec le SDK Firebase.
Il est temps de commencer l'envoi de messages!
Pour envoyer un message à un appareil particulier, vous devez connaître l'identifiant du jeton de l'application que vous souhaitez notifier.
Vous pouvez obtenir cet identifiant de jeton à partir de l'application/du site web que vous utilisez. Ci-dessous, vous trouverez un exemple de la façon d'obtenir l'identifiant du jeton d'une instance de votre application installée sur un appareil Android avec Flutter de manière programmatique:
Avec ce code, vous obtiendrez la variable "jeton". L'identifiant du jeton ressemblera à ce qui suit:
fErQlmmjTsq2E2-p7RN6zD:APA91bFhdeCGit17QSIXrlbfovr59BgviGIDHI0nnp7t9i_YFKAPSACkTvP_iKOV-b3Xaj73uhl7Z0S41vfmH_YVV8Ep9Evad69-s1Hkt9pu3VrkeZQGTc8vAJgKSY1qkhuP7HU6t7UJ
Selon la façon dont vous utilisez votre application, vous pouvez préférer stocker cet identifiant dans Iris avec un identifiant qui identifie votre client. Pour ce faire, vous pouvez utiliser la méthode SaveToken. Vous trouverez un exemple de son fonctionnement dans la classe Test.TestFCM.cls
ClassMethod TestSaveToken()
{
Set token = "fErQlmmjTsq2E2-p7RN6zD:APA91bFhdeCGit17QSIXrlbfovr59BgviGIDHI0nnp7t9i_YFKAPSACkTvP_iKOV-b3Xaj73uhl7Z0S41vfmH_YVV8Ep9Evad69-s1Hkt9pu3VrkeZQGTc8vAJgKSY1qkhuP7HU6t7HJ"Set appName = "appNotas"Set id = 123456Do##class(Firebase.FCM).SaveToken(appName, token, id)
}
Dans ce cas, il peut s'agir de votre identifiant client ou de tout autre identifiant susceptible de vous aider à identifier cet appareil à l'avenir.
Donc, maintenant nous sommes complètement prêts à envoyer un message. Pour ce faire, vous pouvez utiliser l'une des méthodes suivantes:
La première méthode: consiste à envoyer des messages directement à un jeton (méthode Send), voyez l'exemple ci-dessous:
ClassMethod TestSendMessage()
{
Set appName = "appNotas"Set title = "IrisFirebase FCM"Set body = "Now you can send messages from Iris using IrisFirebase!!!"Set image = "https://openexchange.intersystems.com/mp/img/packages/3553/vaeo3isvwgubxb2ya7vb0c9edgs.jpeg"Set token = "fErQlmmjTsq2E2-p7RN6zD:APA91bFhdeCGit17QSIXrlbfovr59BgviGIDHI0nnp7t9i_YFKAPSACkTvP_iKOV-b3Xaj73uhl7Z0S41vfmH_YVV8Ep9Evad69-s1Hkt9pu3VrkeZQGTc8vAJgKSY1qkhuP7HU6t7HJ"Set data = {}
Set data.param1 = "param1 value"Set data.param2 = "param2 value"Set result = ##class(Firebase.FCM).Send(appName, token, title, body, image, data)
If (result = 1)
{
U 0W"Message sended OK"
}Else{
U 0W"Error sending message"
}
}
Comme vous pouvez le constater, pour envoyer un message, vous aurez besoin des éléments suivants:
AppName: C'est le nom de l'application que vous avez écrit dans la méthode ConfigApp.
Le Titre, le Corps et l'Image sont expliqués dans la capture d'écran:
Jeton: il s'agit de l'identifiant du token que vous avez obtenu auprès de l'application.
Data : Il s'agit d'un outil très intéressant (data est un dictionnaire JSON avec une paire de valeurs clés où vous pouvez envoyer des données cachées personnalisées à l'appareil). Peut-être envoyez-vous à votre client les détails de son prochain rendez-vous, vous pouvez donc utiliser cette structure pour envoyer des informations à afficher dans votre application ou ce que vous voulez.
La deuxième méthode: consiste à envoyer un message à un identifiant client (ou autre):
Dans ce cas, vous pouvez utiliser la méthode SendMessageToId. Voyez l'exemple ci-dessous:
ClassMethod TestSendMessageToId()
{
Set appName = "appNotas"Set id = 123456Set title = "título"Set body = "Cuerpo Mensaje"Set image = "https://openexchange.intersystems.com/mp/img/packages/3553/vaeo3isvwgubxb2ya7vb0c9edgs.jpeg"Set token = "fErQlmmjTsq2E2-p7RN6zD:APA91bFhdeCGit17QSIXrlbfovr59BgviGIDHI0nnp7t9i_YFKAPSACkTvP_iKOV-b3Xaj73uhl7Z0S41vfmH_YVV8Ep9Evad69-s1Hkt9pu3VrkeZQGTc8vAJgKSY1qkhuP7HU6t7FD"Set data = {}
Set data.param1 = "param1 value"Set data.param2 = "param2 value"Set result = ##class(Firebase.FCM).SendMessageToId(appName, id, title, body, image, data)
If (result = 1)
{
U 0W"Message sended OK"
}Else{
U 0W"Error sending message"
}
}
Comme vous pouvez le constater, la différence entre la méthode précédente et la présente est que dans ce dernier cas, vous devez connaître l'identifiant de votre jeton enregistré au lieu d'utiliser le jeton à l'aide de la méthode SaveToken.
Les autres paramètres sont les mêmes.
Pour ce faire, vous pouvez utiliser l'outil natif de Firebase pour envoyer des campagnes.
Accédez à la console Firebase, saisissez votre projet et appuyez sur le bouton "Messaging":
Dans cet écran, vous pourrez créer une nouvelle campagne en cliquant sur “New Campaign” ("Nouvelle campagne") puis sur "Notifications":
Vous verrez l'explication détaillée des étapes à suivre pour envoyer le même message à toutes les instances de votre application.
Si vous le souhaitez, vous pouvez appliquer certains filtres au cours du processus:
Vous pourrez programmer votre campagne ou l'envoyer immédiatement:
Vous pouvez également ajouter des analyses:
v:
Lorsque vous êtes prêt, appuyez sur Réviser (Review) et Publier (Publish).
Votre nouvelle campagne apparaîtra dans la section de messagerie "Messaging".
Si vous avez préalablement sélectionné l'option "envoyer immédiatement" ("send now"), vous recevrez la notification dans quelques secondes:
Firebase prétend pouvoir envoyer des millions de messages en quelques secondes. Par conséquent, si vous envisagez d'envoyer le même message à tous vos clients, je vous recommande de créer une campagne plutôt que d'envoyer le même message à tous vos clients un par un à partir d'IRIS. En revanche, si vous envoyez le message à un groupe de clients ou si le message doit être personnalisé pour chaque client, l'envoi à partir d'IrisFirebase est la meilleure option!.
Cliquez sur le lien ci-dessous pour trouver la nouvelle version d'IrisFirebase avec FCM sur l'OpenExchange:
https://openexchange.intersystems.com/package/irisfirebas
Pour découvrir le code de l'application en Flutter que j'ai utilisée dans ce tutoriel, consultez le lien suivant:
https://github.com/daniel-aguilar-garcia/push_app_flutter_example
Voilà, c'est tout pour l'instant. J'espère que vous trouverez cette nouvelle fonctionnalité intrigante et que vous l'utiliserez beaucoup!
Faites-moi savoir dans les commentaires ce que vous pensez de cette nouvelle fonctionnalité. N'hésitez pas à me contacter si vous souhaitez que j'ajoute de nouveaux éléments à IrisFirebase.
Merci d'avoir lu!!
La mise en œuvre de Databricks en SQL d'InterSystems Cloud se compose de quatre parties.
Naviguez vers la page d'aperçu de votre déploiement, si vous n'avez pas activé de connexions externes, faites-le et téléchargez votre certificat et le pilote jdbc depuis la page d'aperçu.
J'ai utilisé intersystems-jdbc-3.8.4.jar et intersystems-jdbc-3.7.1.jar avec succès dans Databricks à partir de la distribution de pilotes Driver Distribution.
La façon la plus simple d'importer un ou plusieurs certificats CA personnalisés dans votre cluster Databricks est de créer un script d'initialisation qui ajoute la chaîne complète de certificats CA aux magasins de certificats par défaut SSL et Java de Linux, et définit la propriété REQUESTS_CA_BUNDLE. Collez le contenu du certificat X.509 que vous avez téléchargé dans le bloc supérieur du script suivant:
import_cloudsql_certficiate.sh
#!/bin/bash
cat << 'EOF' > /usr/local/share/ca-certificates/cloudsql.crt
-----BEGIN CERTIFICATE-----
<PASTE>
-----END CERTIFICATE-----
EOF
update-ca-certificates
PEM_FILE="/etc/ssl/certs/cloudsql.pem"
PASSWORD="changeit"
JAVA_HOME=$(readlink -f /usr/bin/java | sed "s:bin/java::")
KEYSTORE="$JAVA_HOME/lib/security/cacerts"
CERTS=$(grep 'END CERTIFICATE'$PEM_FILE| wc -l)
# Pour traiter plusieurs certificats avec keytool, vous devez extraire# chacun d'eux du fichier PEM et l'importer dans le KeyStore Java.for N in $(seq 0 $(($CERTS - 1))); do
ALIAS="$(basename $PEM_FILE)-$N"echo"Adding to keystore with alias:$ALIAS"
cat $PEM_FILE |
awk "n==$N { print }; /END CERTIFICATE/ { n++ }" |
keytool -noprompt -import -trustcacerts
-alias$ALIAS -keystore $KEYSTORE -storepass $PASSWORDdoneecho"export REQUESTS_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt" >> /databricks/spark/conf/spark-env.sh
echo"export SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt" >> /databricks/spark/conf/spark-env.sh
Maintenant vous avez le script initial, téléchargez-le dans le catalogue Unity sur un Volume.
Une fois que le script est sur un volume, vous pouvez ajouter le script initial au cluster à partir du volume dans les propriétés avancées de votre cluster.
Ensuite, ajoutez le pilote/la bibliothèque intersystems jdbc au cluster...
...et démarrez ou redémarrez votre calcul.
Créez un Notebook Python dans votre espace de travail, attachez-le à votre cluster et testez le glissement de données vers Databricks. Sous le capot, Databricks va utiliser pySpark, si cela n'est pas immédiatement évident.
La construction du Dataframe Spark suivant est tout ce qu'il vous faut, vous pouvez récupérer vos informations de connexion à partir de la page d'aperçu comme auparavant.
df = (spark.read
.format("jdbc")
.option("url", "jdbc:IRIS://k8s-05868f04-a4909631-ac5e3e28ef-6d9f5cd5b3f7f100.elb.us-east-1.amazonaws.com:443/USER")
.option("driver", "com.intersystems.jdbc.IRISDriver")
.option("dbtable", "(SELECT name,category,review_point FROM SQLUser.scotch_reviews) AS temp_table;")
.option("user", "SQLAdmin")
.option("password", "REDACTED")
.option("driver", "com.intersystems.jdbc.IRISDriver")\
.option("connection security level","10")\
.option("sslConnection","true")\
.load())
df.show()
Illustration de la production d'un dataframe à partir de données dans Cloud SQL... boom!
Prenons maintenant ce que nous avons lu dans IRIS et écrivons-le avec Databricks. Si vous vous souvenez bien, nous n'avons lu que 3 champs dans notre cadre de données, nous allons donc les réécrire immédiatement et spécifier un mode "écraser".
df = (spark.read
.format("jdbc")
.option("url", "jdbc:IRIS://k8s-05868f04-a4909631-ac5e3e28ef-6d9f5cd5b3f7f100.elb.us-east-1.amazonaws.com:443/USER")
.option("driver", "com.intersystems.jdbc.IRISDriver")
.option("dbtable", "(SELECT TOP 3 name,category,review_point FROM SQLUser.scotch_reviews) AS temp_table;")
.option("user", "SQLAdmin")
.option("password", "REDACTED")
.option("driver", "com.intersystems.jdbc.IRISDriver")\
.option("connection security level","10")\
.option("sslConnection","true")\
.load())
df.show()
mode = "overwrite"
properties = {
"user": "SQLAdmin",
"password": "REDACTED",
"driver": "com.intersystems.jdbc.IRISDriver",
"sslConnection": "true",
"connection security level": "10",
}
df.write.jdbc(url="jdbc:IRIS://k8s-05868f04-a4909631-ac5e3e28ef-6d9f5cd5b3f7f100.elb.us-east-1.amazonaws.com:443/USER", table="databricks_scotch_reviews", mode=mode, properties=properties)
Exécution du Notebook
Illustration des données dans le Cloud SQL d'InterSystems!
Si vous exécutez IRIS dans une configuration miroir pour HA dans GCP, la question de la fourniture de Mirror VIP (adresse IP virtuelle) devient pertinente. L'adresse IP virtuel permet aux systèmes en aval d'interagir avec IRIS en utilisant une seule adresse IP. Même en cas de basculement, les systèmes en aval peuvent se reconnecter à la même adresse IP et continuer à fonctionner.
Le principal problème, lors du déploiement sur GCP, est qu'un VIP IRIS doit être essentiellement un administrateur de réseau, conformément aux docs.
Pour obtenir l'HA, les membres du miroir IRIS doivent être déployés dans différentes zones de disponibilité d'un sous-réseau (ce qui est possible dans GCP car les sous-réseaux couvrent toujours toute la région). L'une des solutions pourrait être les équilibreurs de charge, mais ils coûtent bien sûr plus cher et nécessitent d'être administrés.
Dans cet article, j'aimerais fournir un moyen de configurer un VIP miroir sans utiliser les équilibreurs de charge suggérés dans la plupart des autres architectures de référence GCP.
Nous avons un sous-réseau qui s'étend sur la région de disponibilité (je simplifie ici - bien sûr, vous aurez probablement des sous-réseaux publics, un arbitre dans une autre zone, et ainsi de suite, mais il s'agit d'un minimum absolu suffisant pour démontrer cette approche). La notation CIRD du sous-réseau est 10.0.0.0/24, ce qui signifie que les adresses IP 10.0.0.1 à 10.0.0.255 lui sont allouées. En tant que GCP réserve les deux premières et dernières adresses, nous pouvons utiliser 10.0.0.2 'à 10.0.0.253'`.
Nous mettrons en œuvre des VIP publics et privés en même temps. Si vous voulez, vous pouvez implémenter uniquement le VIP privé.
Les machines virtuelles dans GCP ont des Interfaces réseau. Ces interfaces réseau ont des Plages IP Alias IP Ranges qui sont des adresses IP privées. Des adresses IP publiques peuvent être ajoutées en spécifiant la configuration d' accès Access Config La configuration d'interfaces réseau est une combinaison d'IP publiques et/ou privées, et elle est acheminée automatiquement vers la Machine virtuelle associée à l'Interface réseau. Il n'est donc pas nécessaire de mettre à jour les routes. Lors d'un basculement de miroir, nous allons supprimer la configuration IP VIP de l'ancien primaire et la créer pour un nouveau primaire. Toutes les opérations nécessaires à cette fin prennent de 5 à 20 secondes pour une IP VIP privée uniquement, de 5 secondes à une minute pour une combinaison d'IP VIP publique/privée.
Pour les VIP externes, vous aurez également besoin de:
C'est tout!
ROUTINE ZMIRROR
NotifyBecomePrimary() PUBLIC {
#include %occMessages
set sc = ##class(%SYS.System).WriteToConsoleLog("Setting Alias IP instead of Mirror VIP"_$random(100))
set sc = ##class(%SYS.Python).Import("set_alias_ip")
quit sc
}
Et voici set_alias_ip.py qui doit être placé dans le répertoire mgr\python:
"""
Ce script ajoute l'Alias IP (https://cloud.google.com/vpc/docs/alias-ip) à l'interface réseau de la VM.
Vous pouvez allouer des plages d'Alias IP à partir de la plage de sous-réseau primaire, ou vous pouvez ajouter une plage secondaire au sous-réseau
et allouer des plages d'alias IP à partir de la plage secondaire.
Pour simplifier, nous utilisons la plage de sous-réseau primaire.
En utilisant Google cli, gcloud, cette action pourrait être effectuée de la manière suivante:
$ gcloud compute instances network-interfaces update <instance_name> --zone=<subnet_zone> --aliases="10.0.0.250/32"
Notez que la commande de suppression des alias est similaire - fournissez simplement un `alias`vide:
$ gcloud compute instances network-interfaces update <instance_name> --zone=<subnet_zone> --aliases=""
Nous utilisons l'API de métadonnées de Google Compute Engine pour récupérer <instance_name> ainsi que <subnet_zone>.
Notez également https://cloud.google.com/vpc/docs/subnets#unusable-ip-addresses-in-every-subnet.
Google Cloud utilise les deux premières et les deux dernières adresses IPv4 de chaque plage d'adresses IPv4 primaires pour héberger le sous-réseau.
Google Cloud vous permet d'utiliser toutes les adresses des plages IPv4 secondaires, c'est-à-dire:
- 10.0.0.0 - Adresse réseau
- 10.0.0.1 - Adresse de la passerelle par défaut
- 10.0.0.254 - Avant-dernière adresse. Réservée pour une utilisation future potentielle
- 10.0.0.255 - Adresse de diffusion
Après avoir ajouté l'adresse de l'Alias IP, vous pouvez vérifier son existence à l'aide de l'utilitaire "ip" :
$ ip route ls table local type local dev eth0 scope host proto 66
local 10.0.0.250
"""
import subprocess
import requests
import re
import time
from google.cloud import compute_v1
ALIAS_IP = "10.0.0.250/32"
METADATA_URL = "http://metadata.google.internal/computeMetadata/v1/"
METADATA_HEADERS = {"Metadata-Flavor": "Google"}
project_path = "project/project-id"
instance_path = "instance/name"
zone_path = "instance/zone"
network_interface = "nic0"
mirror_public_ip_name = "isc-mirror"
access_config_name = "isc-mirror"
mirror_instances = ["isc-primary-001", "isc-backup-001"]
def get_metadata(path: str) -> str:
return requests.get(METADATA_URL + path, headers=METADATA_HEADERS).text
def get_zone() -> str:
return get_metadata(zone_path).split('/')[3]
client = compute_v1.InstancesClient()
project = get_metadata(project_path)
availability_zone = get_zone()
def get_ip_address_by_name():
ip_address = ""
client = compute_v1.AddressesClient()
request = compute_v1.ListAddressesRequest(
project=project,
region='-'.join(get_zone().split('-')[0:2]),
filter="name=" + mirror_public_ip_name,
)
response = client.list(request=request)
for item in response:
ip_address = item.address
return ip_address
def get_zone_by_instance_name(instance_name: str) -> str:
request = compute_v1.AggregatedListInstancesRequest()
request.project = project
instance_zone = ""
for zone, response in client.aggregated_list(request=request):
if response.instances:
if re.search(f"{availability_zone}*", zone):
for instance in response.instances:
if instance.name == instance_name:
return zone.split('/')[1]
return instance_zone
def update_network_interface(action: str, instance_name: str, zone: str) -> None:
if action == "create":
alias_ip_range = compute_v1.AliasIpRange(
ip_cidr_range=ALIAS_IP,
)
nic = compute_v1.NetworkInterface(
alias_ip_ranges=[] if action == "delete" else [alias_ip_range],
fingerprint=client.get(
instance=instance_name,
project=project,
zone=zone
).network_interfaces[0].fingerprint,
)
request = compute_v1.UpdateNetworkInterfaceInstanceRequest(
project=project,
zone=zone,
instance=instance_name,
network_interface_resource=nic,
network_interface=network_interface,
)
response = client.update_network_interface(request=request)
print(instance_name + ": " + str(response.status))
def get_remote_instance_name() -> str:
local_instance = get_metadata(instance_path)
mirror_instances.remove(local_instance)
return ''.join(mirror_instances)
def delete_remote_access_config(remote_instance: str) -> None:
request = compute_v1.DeleteAccessConfigInstanceRequest(
access_config=access_config_name,
instance=remote_instance,
network_interface="nic0",
project=project,
zone=get_zone_by_instance_name(remote_instance),
)
response = client.delete_access_config(request=request)
print(response)
def add_access_config(public_ip_address: str) -> None:
access_config = compute_v1.AccessConfig(
name = access_config_name,
nat_i_p=public_ip_address,
)
request = compute_v1.AddAccessConfigInstanceRequest(
access_config_resource=access_config,
instance=get_metadata(instance_path),
network_interface="nic0",
project=project,
zone=get_zone_by_instance_name(get_metadata(instance_path)),
)
response = client.add_access_config(request=request)
print(response)
# Obtention du nom et de la zone de l'instance d'un autre membre du basculement
remote_instance = get_remote_instance_name()
print(f"Alias IP is going to be deleted at [{remote_instance}]")
# Supprimer l'Alias IP de l'interface réseau d'un membre de basculement distant
#
# TODO : Effectuer les étapes suivantes lorsqu'un problème https://github.com/googleapis/google-cloud-python/issues/11931 sera clôturé:
# - mettre à jour le paquet google-cloud-compute pip vers une version contenant un correctif (>1.15.0)
# - supprimer une ligne ci-dessous appelant gcloud avec un sous-processus subprocess.run()
# - décommenter la fonction update_network_interface()
subprocess.run([
"gcloud",
"compute",
"instances",
"network-interfaces",
"update",
remote_instance,
"--zone=" + get_zone_by_instance_name(remote_instance),
"--aliases="
])
# update_network_interface("delete",
# remote_instance,
# get_zone_by_instance_name(remote_instance)
# Ajouter un Alias IP à l'interface réseau d'un membre du basculement local
update_network_interface("create",
get_metadata(instance_path),
availability_zone)
# Gérer la commutation IP publique
public_ip_address = get_ip_address_by_name()
if public_ip_address:
print(f"Public IP [{public_ip_address}] is going to be switched to [{get_metadata(instance_path)}]")
delete_remote_access_config(remote_instance)
time.sleep(10)
add_access_config(public_ip_address)
Déployons maintenant cette architecture IRIS dans GCP en utilisant Terraform et Ansible. Si vous utilisez déjà IRIS dans GCP ou un autre outil, le script ZMIRROR est disponible ici.
Nous aurons besoin des outils suivants. Ansible étant réservé à Linux, je recommande vivement de l'exécuter sur Linux, même si j'ai confirmé qu'il fonctionnait également sur Windows dans WSL2.
$ gcloud version
Google Cloud SDK 459.0.0
...
$ terraform version
Terraform v1.6.3
$ python3 --version
Python 3.10.12
$ ansible --version
ansible [core 2.12.5]
...
$ ansible-playbook --version
ansible-playbook [core 2.12.5]
...
Si vous utilisez WSL2 sous Windows, vous devrez redémarrer l'agent ssh en exécutant:
eval `ssh-agent -s`
Il arrive également que l'horloge du WSL ne soit pas synchronisée (lorsque Windows passe en mode veille/hibernation et vice-versa), vous devrez peut-être la synchroniser explicitement:
sudo hwclock -s
Si vous utilisez un serveur sans affichage, utilisez gcloud auth login --no-browser pour vous authentifier auprès de GCP.
Nous nous appuyons sur Terraform et stockons son état dans un espace de stockage en nuage. Voir les détails ci-dessous sur la façon dont ce stockage est créé.
$ export PROJECT_ID=<project_id>
$ export REGION=<region> # For instance, us-west1
$ export TF_VAR_project_id=${PROJECT_ID}
$ export TF_VAR_region=${REGION}
$ export ROLE_NAME=MyTerraformRole
$ export SA_NAME=isc-mirror
Remarque: Si vous souhaitez ajouter une VIP publique qui expose publiquement les ports IRIS Mirror (ce qui n'est pas recommandé), vous pouvez l'activer avec:
$ export TF_VAR_enable_mirror_public_ip=true
Il est recommandé d'utiliser Google Artifact Registry au lieu de Container Registry. Créons donc d'abord le registre:
$ cd <root_repo_dir>/terraform
$ cat ${SA_NAME}.json | docker login -u _json_key --password-stdin https://${REGION}-docker.pkg.dev
$ gcloud artifacts repositories create --repository-format=docker --location=${REGION} intersystems
Supposons que les instances de VM n'aient pas accès au dépôt de conteneurs ISC. Mais vous y avez un accès personnel et vous ne voulez pas mettre vos informations d'identification sur les machines virtuelles.
Dans ce cas, vous pouvez extraire les images Docker IRIS du registre de conteneurs ISC et les pousser vers le registre de conteneurs Google auquel les machines virtuelles ont accès:
$ docker login containers.intersystems.com
$ <Put your credentials here>
$ export IRIS_VERSION=2023.2.0.221.0
$ cd docker-compose/iris
$ docker build -t ${REGION}-docker.pkg.dev/${PROJECT_ID}/intersystems/iris:${IRIS_VERSION} .
$ for IMAGE in webgateway arbiter; do \
docker pull containers.intersystems.com/intersystems/${IMAGE}:${IRIS_VERSION} \
&& docker tag containers.intersystems.com/intersystems/${IMAGE}:${IRIS_VERSION} ${REGION}-docker.pkg.dev/${PROJECT_ID}/intersystems/${IMAGE}:${IRIS_VERSION} \
&& docker push ${REGION}-docker.pkg.dev/${PROJECT_ID}/intersystems/${IMAGE}:${IRIS_VERSION}; \
done
$ docker push ${REGION}-docker.pkg.dev/${PROJECT_ID}/intersystems/iris:${IRIS_VERSION}
Mettez le fichier de clé de licence IRIS, iris.key dans <root_repo_dir>/docker-compose/iris/iris.key. Notez qu'une licence doit supporter le Mirroring.
Ce rôle sera utilisé par Terraform pour gérer les ressources GCP nécessaires:
$ cd <root_repo_dir>/terraform/
$ gcloud iam roles create ${ROLE_NAME} --project ${PROJECT_ID} --file=terraform-permissions.yaml
Remarque: utiliser update pour une utilisation ultérieure:
$ gcloud iam roles update ${ROLE_NAME} --project ${PROJECT_ID} --file=terraform-permissions.yaml
$ gcloud iam service-accounts create ${SA_NAME} \
--description="Terraform Service Account for ISC Mirroring" \
--display-name="Terraform Service Account for ISC Mirroring"
$ gcloud projects add-iam-policy-binding ${PROJECT_ID} \
--member="serviceAccount:${SA_NAME}@${PROJECT_ID}.iam.gserviceaccount.com" \
--role=projects/${PROJECT_ID}/roles/${ROLE_NAME}
Générer la clé du compte de service et stocker sa valeur dans une certaine variable d'environnement:
$ gcloud iam service-accounts keys create ${SA_NAME}.json \
--iam-account=${SA_NAME}@${PROJECT_ID}.iam.gserviceaccount.com
$ export GOOGLE_APPLICATION_CREDENTIALS=<absolute_path_to_root_repo_dir>/terraform/${SA_NAME}.json
Stockez une partie privée localement sous .ssh/isc_mirror et rendez-la visible pour ssh-agent. Mettre une partie publique dans un fichier isc_mirror.pub:
$ ssh-keygen -b 4096 -C "isc" -f ~/.ssh/isc_mirror
$ ssh-add ~/.ssh/isc_mirror
$ ssh-add -l # Check if 'isc' key is present
$ cp ~/.ssh/isc_mirror.pub <root_repo_dir>/terraform/templates/
Le stockage dans le nuage est utilisé pour stocker l'état de Terraform à distance. Vous pouvez consulter Store Terraform state in a bucket Cloud Storage comme exemple.
Remarque: Le Cloud Storage créé aura un nom comme isc-mirror-demo-terraform-<project_id>:
$ cd <root_repo_dir>/terraform-storage/
$ terraform init
$ terraform plan
$ terraform apply
$ cd <root_repo_dir>/terraform/
$ terraform init -backend-config="bucket=isc-mirror-demo-terraform-${PROJECT_ID}"
$ terraform plan
$ terraform apply
Remarque 1: Quatre machines virtuelles seront créées. Une seule d'entre elles a une adresse IP publique et joue le rôle d'hôte bastion. Cette machine est appelée isc-client-001. Vous pouvez trouver l'adresse IP publique de l'instance isc-client-001 en exécutant la commande suivante:
$ export ISC_CLIENT_PUBLIC_IP=$(gcloud compute instances describe isc-client-001 --zone=${REGION}-c --format=json | jq -r '.networkInterfaces[].accessConfigs[].natIP')
Remarque 2: Parfois Terraform échoue avec des erreurs comme:
Failed to connect to the host via ssh: kex_exchange_identification: Connection closed by remote host...
Dans ce cas, essayez de purger un fichier local ~/.ssh/known_hosts:
$ for IP in ${ISC_CLIENT_PUBLIC_IP} 10.0.0.{3..6}; do ssh-keygen -R "[${IP}]:2180"; done
et répétez terraform apply.
Toutes les instances, à l'exception de isc-client-001, sont créées dans un réseau privé pour augmenter le niveau de sécurité. Mais vous pouvez y accéder en utilisant la fonctionnalité SSH ProxyJump. Obtenez d'abord l'IP publique de isc-client-001:
$ export ISC_CLIENT_PUBLIC_IP=$(gcloud compute instances describe isc-client-001 --zone=${REGION}-c --format=json | jq -r '.networkInterfaces[].accessConfigs[].natIP')
Then connect to, for example, isc-primary-001 with a private SSH key. Remarquez que nous utilisons un port SSH personnalisé, 2180:
$ ssh -i ~/.ssh/isc_mirror -p 2180 isc@10.0.0.3 -o ProxyJump=isc@${ISC_CLIENT_PUBLIC_IP}:2180
Après la connexion, vérifions que le membre miroir principal a un Alias IP:
[isc@isc-primary-001 ~]$ ip route ls table local type local dev eth0 scope host proto 66
local 10.0.0.250
[isc@isc-primary-001 ~]$ ping -c 1 10.0.0.250
PING 10.0.0.250 (10.0.0.250) 56(84) bytes of data.
64 bytes from 10.0.0.250: icmp_seq=1 ttl=64 time=0.049 ms
Pour ouvrir des instances miroirs des portails de gestion situés dans un réseau privé, nous utilisons SSH Socks Tunneling.
Connectons-nous à l'instance isc-primary-001. Remarquez qu'un tunnel restera en arrière-plan après la prochaine commande:
$ ssh -f -N -i ~/.ssh/isc_mirror -p 2180 isc@10.0.0.3 -o ProxyJump=isc@${ISC_CLIENT_PUBLIC_IP}:2180 -L 8080:10.0.0.3:8080
Le port 8080, au lieu de l'habituel 52773, est utilisé puisque nous démarrons IRIS avec une passerelle WebGateway dédiée fonctionnant sur le port 8080.
Une fois la connexion établie, ouvrez http://127.0.0.1:8080/csp/sys/UtilHome.csp dans un navigateur. Vous devriez voir un portail de gestion. Les informations d'identification sont typiques : _system/SYS.
La même approche fonctionne pour toutes les instances : primaire (10.0.0.3), de sauvegarde (10.0.0.4) et d'arbitre (10.0.0.5). Établissez d'abord une connexion SSH avec eux.
Connectons-nous à ' isc-client-001`:
$ ssh -i ~/.ssh/isc_mirror -p 2180 isc@${ISC_CLIENT_PUBLIC_IP}
Vérifier la disponibilité du portail de gestion du membre miroir primaire sur l'adresse de l'Alias IP:
$ curl -s -o /dev/null -w "%{http_code}\n" http://10.0.0.250:8080/csp/sys/UtilHome.csp
200
Connectons-nous à 'isc-primary-001' sur une autre console:
$ ssh -i ~/.ssh/isc_mirror -p 2180 isc@10.0.0.3 -o ProxyJump=isc@${ISC_CLIENT_PUBLIC_IP}:2180
Et désactivez l'instance principale actuelle. Remarquez qu'IRIS ainsi que son portail Web s'exécutent dans Docker:
[isc@isc-primary-001 ~]$ docker-compose -f /isc-mirror/docker-compose.yml down
Vérifions à nouveau la disponibilité du portail de gestion du membre miroir sur l'adresse IP Alias à partir de isc-client-001 :
[isc@isc-client-001 ~]$ curl -s -o /dev/null -w "%{http_code}\n" http://10.0.0.250:8080/csp/sys/UtilHome.csp
200
Cela devrait fonctionner car l'Alias IP a été déplacé vers l'instance ' isc-backup-001`:
$ ssh -i ~/.ssh/isc_mirror -p 2180 isc@10.0.0.4 -o ProxyJump=isc@${ISC_CLIENT_PUBLIC_IP}:2180
[isc@isc-backup-001 ~]$ ip route ls table local type local dev eth0 scope host proto 66
local 10.0.0.250
$ cd <root_repo_dir>/terraform/
$ terraform init -backend-config="bucket=isc-mirror-demo-terraform-${PROJECT_ID}"
$ terraform destroy
$ cd <root_repo_dir>/terraform
$ cat ${SA_NAME}.json | docker login -u _json_key --password-stdin https://${REGION}-docker.pkg.dev
$ for IMAGE in iris webgateway arbiter; do \
gcloud artifacts docker images delete ${REGION}-docker.pkg.dev/${PROJECT_ID}/intersystems/${IMAGE}
done
$ gcloud artifacts repositories delete intersystems --location=${REGION}
Supprimez le stockage en nuage où Terraform stocke son état. Dans notre cas, il s'agit d'un isc-mirror-demo-terraform-<project_id>.
Supprimez le rôle Terraform créé dans Création d'un rôle Terraform.
Et c'est tout! We change networking configuration pointing to a current mirror Primary when the NotifyBecomePrimary event happens.
L'auteur souhaite remercier @Mikhail Khomenko, @Vadim Aniskin, et @Evgeny Shvarov pour le Programme d'idées de la Communauté (Community Ideas Program) qui a rendu cet article possible.
Nous sommes ravis de continuer à déployer de nouvelles fonctionnalités dans InterSystems IRIS Cloud SQLInterSystems IRIS Cloud SQL, telles que la nouvelle capacité de recherche vectorielle Vector Search qui a été lancée pour la première fois avec InterSystems IRIS 2024.1. Le service Cloud SQL est un service en nuage qui offre précisément ce qui suit: l'accès SQL dans le cloud. Cela signifie que vous utiliserez des technologies de pilote standard telles que JDBC, ODBC et DB-API pour vous connecter à ce service et accéder à vos données. La documentation décrit en détail comment configurer les paramètres importants au niveau du pilote, mais ne présente pas les outils tiers spécifiques car, comme vous pouvez l'imaginer, il en existe un nombre infini.
Dans cet article, nous allons compléter cette documentation de référence avec des étapes plus détaillées pour un outil de visualisation de données tiers populaire que plusieurs de nos clients utilisent pour accéder aux données basées sur IRIS : Microsoft Power BI.
Tout d'abord, connectez-vous au portail des services Cloud Services Portal et créez un déploiement Cloud SQL. Il vous ne faut qu'une chose: cochez la case permettant d'activer les connexions externes. À part cela, tous les paramètres par défaut devraient fonctionner correctement.
Afin de se connecter en toute sécurité, nous utiliserons des certificats pour crypter tout ce qui est envoyé sur le réseau. Vous pouvez télécharger le certificat à partir de la page des détails du déploiement en cliquant sur le bouton "Get X.509 certificate" (Obtenir un certificat X.509):
.png)
Nous devrons nous référer à ce certificat plus tard, il faudra donc l'enregistrer dans un répertoire approprié. Par exemple, j'utilise C:\Users\bdeboe\odbc\.
Pour savoir quels certificats et paramètres de cryptage utiliser, le pilote ODBC d'InterSystems recherche un fichier SSLDefs.ini, que nous allons créer ensuite. Par défaut, il recherche ce fichier dans C:\Program Files (x86)\Common Files\InterSystems\IRIS, mais vous pouvez modifier cet emplacement à l'aide de la variable d'environnement ISC_SSLconfigurationsISC_SSLconfigurations. Pour conserver tous mes paramètres de configuration ensemble, j'ai défini cette variable à C:\Users\bdeboe\odbc\, le répertoire où j'ai également sauvegardé mon certificat.
Le fichier SSLDefs.ini doit contenir deux éléments pour qu'ODBC sache comment se connecter : une configuration de serveur et une configuration SSL. La configuration du serveur déclare simplement le nom de la configuration SSL à utiliser pour une combinaison particulière de nom d'hôte et de port, et la configuration SSL contient tous les détails nécessaires à l'établissement de la connexion cryptée. Il est donc facile de réutiliser une seule configuration SSL pour plusieurs serveurs. Voici le contenu de mon fichier SSLDefs.ini:
[My CloudSQL Server] Address=k8s-da0bcd5e-a1b3a0c7-545df92ec8-2e44304cebef1543.elb.us-east-1.amazonaws.com Port=443 SSLConfig=SampleSSLConfig[SampleSSLConfig] CAFile= CertFile=C:\Users\bdeboe\odbc\certificateSQLaaS.pem KeyFile= Password= KeyType=2 Protocols=28 CipherList=ALL:!aNULL:!eNULL:!EXP:!SSLv2 VerifyPeer=0 VerifyDepth=9
La première section contient la configuration du serveur auquel vous pouvez donner un nom de votre choix. Vous devrez modifier l'adresse pour qu'elle corresponde au nom d'hôte de votre déploiement Cloud SQL, qui peut être obtenu à partir de la page des détails du déploiement où vous avez téléchargé le certificat.
La deuxième section contient la configuration SSL, dont le nom doit correspondre à ce que vous avez spécifié pour SSLConfig dans la section de configuration du serveur. La valeurCertFile doit évidemment correspondre à l'endroit où vous avez sauvegardé votre certificat.
Pour plus de détails sur les autres paramètres, veuillez vous référer à la documentation complète sur les paramètres TLS.
Power BI, comme la plupart des outils basés sur ODBC, fonctionne avec un DSN (Data Source Name), que vous enregistrez à l'aide d'un utilitaire Windows. Il suffit de cliquer sur l'icône Start (Démarrer) de Windows et de taper "ODBC", puis de cliquer sur "ODBC Data Sources (64 bit)" (Sources de données ODBC (64 bit)). Choisissez l'onglet "System DSN" (DSN du système) pour enregistrer une connexion à notre déploiement Cloud SQL. Si vous avez des installations locales d'InterSystems IRIS (j'en ai une douzaine à tout moment 😉), vous verrez que le programme d'installation a créé des entrées DSN par défaut pour:
Cliquez sur "Add..." (Ajouter...) pour créer un nouveau DSN, en choisissant un nom et en renseignant l'hôte, le port et l'espace de noms. J'enregistre habituellement mon nom d'utilisateur et mon mot de passe dans le DSN pour toute instance non productive (et nous en aurons besoin pour tester la connexion dans quelques instants), mais vous pouvez laisser ces champs vides et fournir ces informations d'identification plus tard. Le champ Nom du serveur SSL/TLS est quelque peu superflu (nous y travaillerons!).
Ensuite, cliquez sur "Test Connection" (Tester la connexion) pour vérifier que tout fonctionne comme prévu. Vous devriez obtenir un message "Connectivity test completed successfully!" (Test de connectivité terminé avec succès). Si ce n'est pas le cas, vérifiez les étapes ci-dessus ou reportez-vous au Guide de dépannage. Un message d'erreur particulier peut vous laisser perplexe (en tout cas, il m'a laissé perplexe !): "No SSL config found in the registry or in ssldefs.ini" (Aucune configuration SSL trouvée dans le registre ou dans ssldefs.ini). Cette erreur signifie que le pilote ODBC n'a pas trouvé de correspondance pour votre combinaison nom d'hôte/port dans le fichier SSLDefs.ini. Comme votre nom d'hôte change à chaque fois que vous créez un nouveau déploiement, vous devrez mettre à jour ou ajouter les configurations de serveur pour chacun d'entre eux.
Il est maintenant temps d'utiliser notre DSN ODBC pour extraire des données dans Power BI. Après avoir ouvert l'application, sélectionnez la commande "Get Data" (Obtenir des données) ou "Get data from other sources" (Obtenir des données à partir d'autres sources), et choisissez l'option ODBC:
.png)
Ensuite, choisissez le DSN que vous venez de créer dans la liste:
.png)
Dans l'écran suivant, vous pouvez indiquer votre nom d'utilisateur et votre mot de passe. Aucune propriété des informations d'identification supplémentaire n'est requise.
Et c'est tout! Vous pouvez maintenant sélectionner les tables que vous souhaitez inclure dans vos rapports Power BI:
.png)
Comme vous l'avez probablement remarqué, toutes les étapes de cet article, à l'exception de la dernière, sont universelles pour la configuration ODBC, ce qui devrait vous permettre d'utiliser la plupart des outils basés sur ODBC. J'espère que cet article vous a permis d'avancer, et n'hésitez pas à ajouter vos propres trucs et astuces, ou à partager vos expériences sur la connexion à Cloud SQL. Notez également qu'il n'y a pratiquement rien ici, à part l'étape 0, qui soit spécifique à Cloud SQL, donc vous pouvez utiliser les mêmes étapes pour vous connecter à n'importe quelle instance IRIS qui nécessite des connexions cryptées.
Salut la Communauté!
Profitez de regarder la nouvelle vidéo sur la chaîne Youtube d'InterSystems France.
Si vous exécutez IRIS dans une configuration miroir pour HA dans Azure, la question de la fourniture de Mirror VIP (adresse IP virtuelle) devient pertinente. L'adresse IP virtuel permet aux systèmes en aval d'interagir avec IRIS en utilisant une seule adresse IP. Même en cas de basculement, les systèmes en aval peuvent se reconnecter à la même adresse IP et continuer à fonctionner.
Le principal problème, lors du déploiement sur Azure, est qu'un VIP IRIS doit être essentiellement un administrateur de réseau, conformément aux docs.
Pour obtenir l'HA, les membres du miroir IRIS doivent être déployés dans différentes zones de disponibilité d'un sous-réseau (ce qui est possible dans Azure car les sous-réseaux peuvent s'étendre sur plusieurs zones). L'une des solutions pourrait être les équilibreurs de charge, mais ils coûtent bien sûr plus cher et nécessitent d'être administrés.
Dans cet article, j'aimerais fournir un moyen de configurer un VIP miroir sans utiliser les équilibreurs de charge suggérés dans la plupart des autres architectures de référence Azure.
Nous avons un sous-réseau qui s'étend sur deux zones de disponibilité (je simplifie ici - bien sûr, vous aurez probablement des sous-réseaux publics, un arbitre dans une autre zone, et ainsi de suite, mais il s'agit d'un minimum absolu suffisant pour démontrer cette approche). La notation CIDR du sous-réseau est 10.0.0.0/24, ce qui signifie que les adresses IP 10.0.0.1 à 10.0.0.255 lui sont allouées. Puisque Azure réserve les quatre premières adresses et la dernière adresse, nous pouvons utiliser 10.0.0.4 à 10.0.0.254.
Nous mettrons en œuvre des VIP publics et privés en même temps. Si vous voulez, vous pouvez implémenter uniquement le VIP privé.
Les machines virtuelles dans Azure ont des Interfaces réseau. Ces interfaces réseau ont des Configurations IP. La configuration IP est une combinaison d'IP publiques et/ou privées, et elle est acheminée automatiquement vers la Machine virtuelle associée à l'Interface réseau. Il n'est donc pas nécessaire de mettre à jour les routes. Lors d'un basculement de miroir, nous allons supprimer la configuration IP VIP de l'ancien primaire et la créer pour un nouveau primaire. Toutes les opérations nécessaires à cette fin prennent de 5 à 20 secondes pour une IP VIP privée uniquement, de 5 secondes à une minute pour une combinaison d'IP VIP publique/privée.
'10.0.0.254'eth0:1.cat << EOFVIP >> /etc/sysconfig/network-scripts/ifcfg-eth0:1
DEVICE=eth0:1
ONPARENT=on
IPADDR=10.0.0.254
PREFIX=32
EOFVIP
sudo chmod -x /etc/sysconfig/network-scripts/ifcfg-eth0:1
sudo ifconfig eth0:1 up
Si vous voulez juste faire un test, exécutez-le (mais il ne survivra pas au redémarrage du système) :
sudo ifconfig eth0:1 10.0.0.254
Selon le système d'exploitation que vous devrez peut-être exécuter:
ifconfig eth0:1
systemctl restart network
{
"roleName": "custom_nic_write",
"description": "IRIS Role to assign VIP",
"assignableScopes": [
"/subscriptions/{subscriptionid}/resourceGroups/{resourcegroupid}/providers/Microsoft.Network/networkInterfaces/{nicid_primary}",
"/subscriptions/{subscriptionid}/resourceGroups/{resourcegroupid}/providers/Microsoft.Network/networkInterfaces/{nicid_backup}"
],
"permissions": [
{
"actions": [
"Microsoft.Network/networkInterfaces/write",
"Microsoft.Network/networkInterfaces/read"
],
"notActions": [],
"dataActions": [],
"notDataActions": []
}
]
}
Pour les environnements non productifs, vous pouvez utiliser un rôle système Contributeur réseau sur le groupe de ressources, mais ce n'est pas une approche recommandée car Contributeur réseau est un rôle très large.
Voici les commandes Azure CLI pour les deux nœuds en supposant le groupe de ressources rg, la configuration IP vip et l'IP externe my_vip_ip :
az login --identity
az network nic ip-config delete --resource-group rg --name vip --nic-name mirrorb280_z2
az network nic ip-config create --resource-group rg --name vip --nic-name mirrora290_z1 --private-ip-address 10.0.0.254 --public-ip-address my_vip_ip
et
az login --identity
az network nic ip-config delete --resource-group rg --name vip --nic-name mirrora290_z1
az network nic ip-config create --resource-group rg --name vip --nic-name mirrorb280_z2 --private-ip-address 10.0.0.254 --public-ip-address my_vip_ip
Et le même code qu'une routine ZMIRROR :
ROUTINE ZMIRROR
NotifyBecomePrimary() PUBLIC {
#include %occMessages
set rg = "rg"
set config = "vip"
set privateVIP = "10.0.0.254"
set publicVIP = "my_vip_ip"
set nic = "mirrora290_z1"
set otherNIC = "mirrorb280_z2"
if ##class(SYS.Mirror).DefaultSystemName() [ "MIRRORB" {
// we are on mirrorb node, swap
set $lb(nic, otherNIC)=$lb(otherNIC, nic)
}
set rc1 = $zf(-100, "/SHELL", "export", "AZURE_CONFIG_DIR=/tmp", "&&", "az", "login", "--identity")
set rc2 = $zf(-100, "/SHELL", "export", "AZURE_CONFIG_DIR=/tmp", "&&", "az", "network", "nic", "ip-config", "delete", "--resource-group", rg, "--name", config, "--nic-name", otherNIC)
set rc3 = $zf(-100, "/SHELL", "export", "AZURE_CONFIG_DIR=/tmp", "&&", "az", "network", "nic", "ip-config", "create", "--resource-group", rg, "--name", config, "--nic-name", nic, "--private-ip-address", privateVIP, "--public-ip-address", publicVIP)
quit 1
}
La routine est la même pour les deux membres du miroir, nous échangeons simplement les noms des cartes réseau en fonction du nom du membre du miroir actuel. Vous pourriez ne pas avoir besoin du paramètre export AZURE_CONFIG_DIR=/tmp, mais parfois az cherche à écrire les informations d'identification dans le répertoire personnel de la racine, ce qui peut échouer. Au lieu de /tmp, il est préférable d'utiliser le sous-répertoire personnel de l'utilisateur d'IRIS (ou vous pouvez même ne pas avoir besoin de cette variable d'environnement, en fonction de votre configuration).
Et si vous voulez utiliser Embedded Python, voici le code Azure Python SDK:
from azure.identity import DefaultAzureCredential
from azure.mgmt.network import NetworkManagementClient
from azure.mgmt.network.models import NetworkInterface, NetworkInterfaceIPConfiguration, PublicIPAddress
sub_id = "AZURE_SUBSCRIPTION_ID"
client = NetworkManagementClient(credential=DefaultAzureCredential(), subscription_id=sub_id)
resource_group_name = "rg"
nic_name = "mirrora290_z1"
other_nic_name = "mirrorb280_z2"
public_ip_address_name = "my_vip_ip"
private_ip_address = "10.0.0.254"
vip_configuration_name = "vip"
# remove old VIP configuration
nic: NetworkInterface = client.network_interfaces.get(resource_group_name, other_nic_name)
ip_configurations_old_length = len(nic.ip_configurations)
nic.ip_configurations[:] = [ip_configuration for ip_configuration in nic.ip_configurations if
ip_configuration.name != vip_configuration_name]
if ip_configurations_old_length != len(nic.ip_configurations):
poller = client.network_interfaces.begin_create_or_update(
resource_group_name,
other_nic_name,
nic
)
nic_info = poller.result()
# add new VIP configuration
nic: NetworkInterface = client.network_interfaces.get(resource_group_name, nic_name)
ip: PublicIPAddress = client.public_ip_addresses.get(resource_group_name, public_ip_address_name)
vip = NetworkInterfaceIPConfiguration(name=vip_configuration_name,
private_ip_address=private_ip_address,
private_ip_allocation_method="Static",
public_ip_address=ip,
subnet=nic.ip_configurations[0].subnet)
nic.ip_configurations.append(vip)
poller = client.network_interfaces.begin_create_or_update(
resource_group_name,
nic_name,
nic
)
nic_info = poller.result()
NotifyBecomePrimary est aussi appelé automatiquement au démarrage du système (après la reconnexion de miroirs), mais si vous voulez que vos environnements non-miroirs acquièrent VIP de la même manière, utilisez la routine ZSTART:
SYSTEM() PUBLIC {
if '$SYSTEM.Mirror.IsMember() {
do NotifyBecomePrimary^ZMIRROR()
}
quit 1
}
Et c'est tout! Nous changeons la configuration IP qui pointe vers un miroir primaire actuel lorsque l'événement NotifyBecomePrimary se produit.
Dans ce deuxième article sur les principes fondamentaux des conteneurs, nous examinons ce que sont les images de conteneurs.
Une image Docker est simplement une représentation binaire d'un conteneur.
Un conteneur en cours d'exécution ou simplement un conteneur est l'état d'exécution de l'image du conteneur associée.
Pour plus d'information, n'hésitez pas à lire l'article qui explique ce qu'est un conteneur.
Avec la sortie d'InterSystems IRIS Cloud SQL, nous recevons des questions plus fréquentes sur la manière d'établir des connexions sécurisées via JDBC et d'autres technologies de pilotes.
Bien que nous ayons une belle documentation générale et détaillée sur les technologies de pilote elles-mêmes, notre documentation ne va pas aussi loin pour décrire les outils clients individuels, tels que notre DBeaver préféré.
Dans cet article, nous décrirons les étapes pour créer une connexion sécurisée de DBeaver à votre déploiement Cloud SQL.
InterSystems a le plaisir d'annoncer la disponibilité générale d'InterSystems IRIS Cloud SQL et d'InterSystems IRIS Cloud IntegratedML, deux services fondamentaux pour le développement de solutions cloud natives optimisées par les performances et la fiabilité éprouvées de classe entreprise de la technologie InterSystems IRIS.
Bonjour les développeurs,
Commencez à regarder notre dernière vidéo sur InterSystems Developers YouTube:
⏯ North West London Integrated Care System Go Live with Health Connect Cloud @ Global Summit 2023
Salut la Communauté!
Profitez de regarder la nouvelle vidéo sur le moyen de se connecter aux InterSystems Cloud Services à partir de votre application Java à l'aide du pilote JDBC InterSystems.
Dans cette série d'articles, j'aimerais présenter et discuter de plusieurs approches possibles pour le développement de logiciels avec les technologies d'InterSystems et GitLab. J'aborderai des sujets tels que:
Dans cet article, nous allons créer une diffusion continue avec InterSystems Cloud Manager. ICM est une solution de déploiement et de provisionnement en nuage pour les applications basées sur InterSystems IRIS. Il vous permet de définir la configuration de déploiement souhaitée et ICM la provisionne automatiquement. Pour plus d'informations, consultez : First Look : ICM.
Salut la Communauté!
Profitez de regarder la nouvelle vidéo sur le moyen de se connecter aux InterSystems Cloud Services à partir de votre application .NET à l'aide de l'InterSystems ADO.NET Managed Provider.
Salut la Communauté!
Profitez de regarder la nouvelle vidéo sur le moyen de se connecter aux InterSystems Cloud Services à partir de l'application Python à l'aide du pilote InterSystems DB-API.
Salut la Communauté!
Découvrez notre première vidéo, doublée grâce à l'intelligence artificielle (IA) !
Profitez de regarder la nouvelle vidéo sur le moyen de se connecter aux InterSystems Cloud Services à partir de l'application C++, à l'aide du pilote ODBC InterSystems.
InterSystems a pris la décision d'arrêter le développement d'InterSystems Cloud Manager et de le qualifier de obsolète à partir de la version InterSystems IRIS 2023.3. InterSystems continuera à prendre en charge les clients existants utilisant cette technologie, mais elle n'est plus recommandée pour les nouveaux déploiements.
Les clients du cloud qui souhaitent déployer et gérer un déploiement IRIS avec de nombreux systèmes sont encouragés à envisager Kubernetes et InterSystems Kubernetes Operator, qui possède des fonctionnalités très similaires à ICM.
Salut la Communauté,
regardez la nouvelle vidéo InterSystems Developers YouTube:
⏯ Best Practices for InterSystems IRIS System Performance in the Cloud @ Global Summit 2023
Bonjour la communauté,
je vous invite à regarder la nouvelle vidéo sur InterSystems Developers YouTube:
Dans le dernier article, nous avons parlé de quelques éléments de démarrage pour Django. Nous avons appris à commencer le projet, à nous assurer que nous disposons de tous les éléments requis et à créer une matrice CRUD. Cependant, aujourd'hui, nous allons un peu plus loin.
Aujourd'hui, nous allons donc connecter IRIS à un environnement Python, construire quelques fonctions et les afficher sur une page web. Ce sera similaire à la dernière discussion, mais nous irons assez loin pour que vous puissiez faire quelque chose de nouveau, mais pas assez pour que vous vous sentiez perdus.
Dans ce projet, nous obtiendrons des informations sur les globales dans IRIS afin de suivre leur taille et de comprendre le coût de chaque espace de noms et de chaque table en Mo.
Chaque étape est disponible sur mon Référentiel GitHub, dans l'historique des commits.
Nous suivons quelques étapes similaires à celles de l'article précédent, alors cette partie vous sera familière.
django-admin startproject globalSize
pip install -r requirements.txt
pour être sûr de remplir les conditions requises.
# Django en lui-même
django>=4.2.1# Pilote InterSystems IRIS pour Django
django-iris==0.2.2DATABASES = {
‘default’: {
‘ENGINE’: ‘django_iris’,
‘NAME’: ‘USER’,
‘USER’: ‘_system’,
‘PASSWORD’: ‘SYS’,
‘HOST’: ‘localhost’,
‘PORT’: 1972,
}
}
Nous avons créé une application et un modèle dans le dernier article, cette section devrait donc vous être familière, même s'il s'agit d'une application et d'un modèle différents.
python manage.py startapp globals
classirisGlobal(models.Model):
database = models.CharField(max_length=40)
name = models.CharField(max_length=40)
allocatedsize = models.FloatField()
size = models.FloatField()
def__str__(self):return self.nameINSTALLED_APPS = [
…,
‘globals’,
]
Une fois de plus, nous suivons quelques étapes similaires à celles de l'article précédent.
from django.urls import path, include
urlpatterns = [
…,
path(‘globals/’, include(‘globals.urls’)),
]from django.urls import path
from .views import home
urlpatterns = [
path(‘’, home),
]defhome(request):return render(request, “index.html”)
hello world!
Si vous entrez les commandes ci-dessous et suivez le lien http://127.0.0.1:8000/globals/, vous aurez une page affichant "hello world !".
python manage.py makemigrations<br>python manage.py migrate<br>python manage.py runserver
Affichage des globales dans les pages d'accueil et d'administration
from .models import irisGlobal
admin.site.register(irisGlobal)from .models import irisGlobal
defhome(request):
globals = irisGlobal.objects.all()
return render(request, “index.html”, {“globals”: globals})
ID - DATABASE / GLOBAL - Size / Allocated
{% for global in globals %}
>
{{ global.id }} - {{ global.database }} {{ global.name }} - {{ global.size }} / {{ global.allocatedsize }}
{% endfor %}
Récupération de données
À ce stade, le projet est prêt à recevoir des informations. Il existe de nombreuses façons de modeler ce projet, mais pour ma part, j'utiliserai l'approche de Python afin que nous puissions apprendre une nouvelle solution qu'il est possible d'intégrer à Django et à IRIS.
Nous avons besoin de quelques méthodes pour récupérer toutes les données. Nous pouvons utiliser InterSystems IRIS Cloud SQL avec le pilote DB-API pour nous connecter à l'instance que nous voulons analyser - il n'est pas nécessaire que ce soit la même que celle où nous avons connecté Django.
L'organiser dans un nouveau dossier que nous pouvons traiter comme un module est une bonne pratique. Pour cela, créez le dossier api dans les globaux, ajoutez un fichier vide _init_.py_ pour que Python le reconnaisse comme un module, et commencez à écrire le fichier qui contiendra les méthodes. Nous pouvons l'appeler methods.py.
Pour connecter notre environnement Python à l'IRIS d'InterSystems, nous devons suivre quelques étapes décrites dans la section "ObjectScript dans l'environnement Python" de l'article précédent [Python et IRIS dans la pratique] (https://community.intersystems.com/post/python-and-iris-practice-examples).
A partir de maintenant, c'est simple ; nous importons iris, nous passons l'adresse de la connexion (l'instance d'IRIS que nous voulons analyser dans le format suivant : host:port/namespace), un nom d'utilisateur et un mot de passe à la méthode iris.connect et nous créons IRIS de Python. Jetez un coup d'œil au code ci-dessous.
import intersystems_iris as iris
from django.db import connection as djangoconnection
# connection par iris
conn_params = djangoconnection.get_connection_params()
conn_params[“namespace”] = “%SYS”
connection = iris.connect(**conn_params)
irisPy = iris.createIRIS(connection)
Puisque nous voulons récupérer les tailles des globales, nous avons besoin (bien sûr) de leurs tailles, de leurs noms et de leurs adresses - ce que nous appelons des bases de données.
Je vais vous montrer une version simplifiée de la fonction, mais rappelez-vous qu'il est préférable de vérifier chaque étape et chaque connexion, et de lancer une exception si quelque chose ne va pas.
Tout comme nous le ferions en ObjectScript, nous avons besoin d'une requête SQL pour pouvoir la préparer, l'exécuter et récupérer une liste contenant tous les répertoires de la base de données dans son jeu de résultats. Nous pouvons faire tout cela facilement avec les fonctions "irisPy.classMethodSomething()", où Something (quelque chose) représente le type que la méthode doit retourner, et irisObject.invoke(), où nous pouvons accéder à n'importe quoi à partir de l'irisObject référencé. Voici un exemple.
defgetAllDatabaseDirectories():try:
# vérification de la connexion faite dans irisPy, et si elle est fixée à l'espace de noms %SYS
databaseDirectoriesList = []
with connection.cursor() as cursor:
cursor.execute(“SELECT DISTINCT %EXACT(Directory) FROM Config.Databases WHERE SectionHeader = ?”, [“Databases”,],)
databaseDirectoriesList = [row[0] for row in cursor]
except Exception as error:
return str(error)
return databaseDirectoriesList
La variable statement est définie comme un objet généré par la méthode %New de la classe IRIS %SQL.Statement. Il est alors possible d'invoquer la méthode %Prepare à partir de l'objet instancié, avec une chaîne de requête comme argument. Ensuite, nous pouvons invoquer les méthodes %Execute et %Next pour exécuter la requête et boucler sur l'ensemble des résultats, en ajoutant les informations souhaitées à une liste Python pour un accès facile.
Il est facile de trouver chaque répertoire de base de données dans le tableau Config.Databases, situé uniquement dans l'espace de noms %SYS de chaque instance d'IRIS. Consultez-la dans le portail de gestion si vous le souhaitez, vous y trouverez d'autres informations intéressantes.
Cette fonction est très similaire à la précédente. Cependant, nous disposons maintenant d'une requête de classe prête à l'emploi. Une fois de plus, nous avons besoin d'une requête SQL, nous pouvons donc préparer la requête DirectoryList à partir de la classe %SYS.GlobalQuery. Ensuite, nous l'exécutons avec un répertoire de base de données comme argument et nous récupérons une liste contenant tous les globales de cette base de données.
defgetGlobalsList(databaseDirectory: str):try:
statement = irisPy.classMethodObject("%SQL.Statement", "%New")
status = statement.invoke("%PrepareClassQuery", "%SYS.GlobalQuery","DirectoryList")
result = statement.invoke("%Execute", databaseDirectory)
globalList = []
while (result.invoke("%Next")!=0):
globalList.append(result.invoke("%Get", "Name"))
except Exception as error:
return str(error)
return globalListRécupération des tailles des globales et des tailles allouées
Enfin, nous pouvons accéder aux informations cibles. Heureusement, IRIS dispose d'une méthode intégrée pour récupérer la taille et la taille allouée à condition de fournir une base de données et une paire de globales.
defgetGlobalSize(databaseDirectory: str, globalName: str):try:
globalUsed = iris.IRISReference(0)
globalAllocated = iris.IRISReference(0)
status = irisPy.classMethodObject("%GlobalEdit", "GetGlobalSize", databaseDirectory, globalName, globalAllocated, globalUsed, 0)
except Exception as error:
return str(error)
return (globalUsed.getValue(), globalAllocated.getValue())
Cette fois, nous avons besoin de la fonction IRISReference(0) du module iris pour recevoir les tailles de la fonction "GetGlobalSize" par référence. Ensuite, nous pouvons accéder à la valeur avec la méthode getValue().
Enfin, nous pouvons utiliser ces fonctions pour afficher les données sur la page d'accueil. Nous disposons déjà d'un moyen pour accéder aux informations et d'un tableau, il ne nous reste plus qu'à le remplir. Pour cela, je veux créer un bouton de mise à jour.
Tout d'abord, nous ajoutons un lien vers le fichier index.html.
…
href = "{% url 'update' %}">updatea>
…
body>Ajoutez le lien vers la liste urlpatterns, dans urls.py.
Add the link to the urlpatterns list, in urls.py.
from .views import home, update
urlpatterns = [
path('', home),
path('update', update, name="update"),
]Ensuite, créez la vue, dans views.py.
from django.shortcuts import render, redirect
from .api.methods import *
defupdate(request):
irisGlobal.objects.all().delete()
databaseList = getAllDatabaseDirectories()
for database in databaseList:
globalList = getGlobalsList(database)
for glob in globalList:
used, allocated = getGlobalSize(database, glob)
irisGlobal.objects.create(database=database, name=glob, size=used, allocatedsize=allocated)
return redirect(home)
Pour cette vue, nous devons d'abord importer la fonction de redirection de django.shortcuts, ainsi que les méthodes que nous venons de construire.
C'est une bonne idée de supprimer toutes les données précédentes du tableau afin que les globales éventuellement supprimées disparaissent. Comme le nombre de globales n'est probablement pas gigantesque, il est préférable de procéder ainsi plutôt que de vérifier chaque enregistrement pour voir s'il a été supprimé ou s'il a besoin d'une mise à jour.
Ensuite, nous obtenons tous les répertoires des bases de données afin de pouvoir, pour chaque base de données, vérifier tous les globales qui s'y trouvent, et pour chaque globale, nous pouvons avoir sa taille utilisée et sa taille allouée.
À ce stade, le modèle Django est rempli et prêt à récupérer des données, nous redirigeons donc vers la vue d'accueil.
Si vous accédez à <http://127.0.0.1:8000/globals/> et cliquez sur le lien de mise à jour que nous avons ajouté, la page devrait se recharger et dans quelques secondes, elle affichera la liste des globales, avec ses bases de données, ses tailles et ses tailles allouées, comme dans l'image ci-dessous.
Vous seriez surpris de savoir à quel point il est simple d'ajouter quelques options d'analyse rapide, telles qu'une somme ou un décompte. Il n'est pas nécessaire de maîtriser Django pour créer quelques tableaux de bord sur cette page et, après cette section, vous devriez être en bonne position pour commencer.
Nous savons déjà que la vue accueil est responsable du rendu de l'index. Jusqu'à présent, nous avons généré la variable "globals", contenant toutes les données, et l'avons passée à l'index.html. Nous allons faire quelque chose de similaire, mais avec des fonctions d'agrégation. Nous allons créer une variable pour chaque somme, utiliser les méthodes aggregate() et Sum(), et les ajouter à l'argument "context list" de la fonction "render". Et bien sûr, n'oubliez pas d'importer "Sum" de django.db.models. Consultez la fonction ci-dessous.
defhome(request):
globals = irisGlobal.objects.all()
sumSize = globals.aggregate(Sum("size"))
sumAllocated = globals.aggregate(Sum("allocatedsize"))
return render(request, "index.html", {"globals": globals, "sumSize": sumSize, "sumAllocated":sumAllocated})
Nous pouvons maintenant l'ajouter au fichier index.html et ajouter quelques paragraphes sous la liste (
élément). Dans ces paragraphes, nous pouvons accéder au décompte de toutes les globales et aux sommes, comme indiqué ci-dessous.
…
showing results for {{globals.count}} globalsp>total size: {{sumSize.size__sum}}p><total allocated size: {{sumAllocated.allocatedsize__sum}}p>body>html>Actualisez le lien et vous devriez obtenir le résultat suivant.
Dans cet article, nous avons appris comment InterSystems IRIS stocke les données en mémoire, comment y accéder à partir de Python, comment construire une API, et comment utiliser IRIS comme un système en nuage, de sorte que nous puissions le suivre et l'analyser facilement. Nous pouvons voir à l'horizon des requêtes plus complexes, la création de tableaux de bord, l'automatisation des mises à jour et l'ajout d'un système de notification.
Dans le prochain article, je me rapprocherai de cet horizon, en montrant comment filtrer et ordonner les données avant de les afficher, en ajoutant quelques options modifiables côté client, et enfin, en ajoutant une pincée de CSS pour donner du charme à l'ensemble.
Souhaitez-vous voir quelque chose que je n'ai pas encore dit ? N'hésitez pas à me contacter si vous avez des idées ou des besoins sur lesquels vous aimeriez que j'écrive.
InterSystems IRIS Cloud SQL est un service cloud entièrement géré qui apporte la puissance des capacités de base de données relationnelles d'InterSystems IRIS utilisées par des milliers d'entreprises clientes à un large public de développeurs d'applications et de professionnels des données. InterSystems IRIS Cloud IntegratedML est une option de cette base de données en tant que service qui offre un accès facile à de puissantes capacités d'apprentissage automatique automatisé sous une forme SQL native, via un ensemble de commandes SQL simples qui peuvent facilement être intégrées dans le code d'application pour augmenter avec des modèles ML qui s'exécutent près des données.
Aujourd'hui, nous annonçons le programme d'accès pour les développeurs pour ces deux offres. Les développeurs d'applications peuvent désormais s'inscrire eux-mêmes au service, créer des déploiements et commencer à créer des applications composables et des services de données intelligents, l'approvisionnement, la configuration et l'administration étant entièrement pris en charge par le service.
Si vous déployez dans plus d'un environnement/région/cloud/client, vous rencontrerez inévitablement le problème de la gestion de la configuration.
Alors que tous vos déploiements (ou juste certains) peuvent partager le même code source, certaines parties, telles que la configuration (paramètres, mots de passe) diffèrent d'un déploiement à l'autre et doivent être gérées différemment.
Dans cet article, j'essaierai d'offrir quelques conseils à ce sujet. Cet article traite principalement des déploiements de conteneurs.
Avant d'aborder la gestion de la configuration, parlons de l'unification des bases de code. Le problème est le suivant : la base de code doit généralement viser à coalescer en une seule version. Bien sûr, à tout moment, vous aurez plusieurs versions de votre base de code - la version DEV avec de toutes nouvelles fonctionnalités, la version TEST avec du code de test supplémentaire, la version PROD, et ainsi de suite. Et c'est fine parce que, dans cet exemple, les changements se regroupent en une seule version au fil du temps. Plusieurs branches DEV deviennent une branche TEST et ainsi de suite.
Le problème commence lorsque nous avons plusieurs versions à l'étape finale de notre pipeline de déploiement. Par exemple, le client ABC a demandé une fonctionnalité particulière XYZ, et il existe maintenant deux versions de la base de code PROD - avec la fonctionnalité XYZ et sans elle. Cette situation est problématique car elle double immédiatement nos délais de construction et notre consommation de ressources. Bien sûr, il n'y a parfois aucun moyen d'y remédier. Cependant, supposons que vous ayez de telles divergences persistantes entre les bases de code. Dans ce cas, il peut être intéressant de rechercher si vous pouvez les regrouper en une seule version - dans ce scénario, la fonctionnalité XYZ est activée ou non au démarrage.
Cela dit, passons à la gestion de la configuration.
Qu'est-ce que nous voulons ?
* Ne pas stocker toutes les configurations possibles dans un seul conteneur ( pour une part, ce n'est pas sûr, et pour une autre part, nous avons toujours besoin de choisir la configuration à appliquer).
* Ne pas construire un conteneur pour chaque configuration (simplifie le pipeline CD)
Nous devons transmettre la configuration (paramètres, secrets, ...) lors du démarrage d'InterSystems IRIS et l'appliquer à notre application.
Il existe plusieurs façons de transmettre la configuration au démarrage.
Simple et rapide. Dans le cas où vous souhaitez tout stocker dans une seule variable, utilisez JSON pour la sérialisation. N'oubliez pas par ailleurs que Windows a une limite de 32K caractères pour les variables d'environnement (mégaoctets sous Linux). Pour récupérer une variable d'environnement, utilisez $SYSTEM.Util.GetEnviron("ENV_VAR\NAME"). Le principal avantage est la facilité de mise en œuvre. Vérifiez également votre outil CD - il a généralement un minimum de support des variables d'environnement pendant l'exécution du pipeline, parfois avec un support des secrets pour plus de sécurité.
La configuration peut être un fichier de montage au démarrage. L'avantage est qu'il n'y a pas de limite de longueur. L'inconvénient est que toutes les offres en nuage ne prennent pas en charge les fichiers de montage, et même si c'est le cas, la gestion des fichiers peut s'avérer plus délicate que celle des variables d'environnement. Sachez que les fichiers peuvent toujours être récupérés à partir des anciennes couches d'un conteneur, même s'ils ont été supprimés à une couche ultérieure.
Les paramètres du système peuvent être transmis via le Fichier de fusion de configuration. Ainsi que ses fonctionnalités intégrées. Inconvénient : Le fichier de fusion CPF ne traite pas les paramètres au niveau de l'application.
Docker peut monter un secret sous une forme de fichier à l'intérieur d'un conteneur. Les offres en nuage proposent souvent une fonctionnalité similaire. Utilisez-la à la place des fichiers ordinaires pour améliorer la sécurité.
Bien, vous avez passé la configuration à l'intérieur d'un conteneur. Que faire maintenant ?
%ZSTART est votre code personnalisé, exécuté au démarrage du système. Il ressemble à ceci :
SYSTEM
try {
new $namespace
set $namespace = "USER"
// apply configuration
set $namespace = "%SYS"
} catch ex {
zn "%SYS"
do ex.Log()
}
quit 1
Il est essentiel de noter que %ZSTART doit être testé complètement - car InterSystems IRIS ne démarrera pas (ou se comportera de manière erratique) si la routine %ZSTART renvoie une erreur.
Vous êtes maintenant prêt à appliquer vos paramètres.
La manière dont vous stockez/appliquez les paramètres au niveau de l'application dépend naturellement de l'application, mais les paramètres par défaut du systèmeSystem Default Settings{.editor-rtfLink} sont disponibles si vous utilisez l'interopérabilité. Même si vous n'utilisez pas de productions interopérables, vous pouvez toujours utiliser les paramètres par défaut du système car ils sont disponibles pour tout le monde (tant que l'interopérabilité est activée dans un espace de noms).
Pour créer un nouveau paramètre, exécutez :
Set setting = ##class(Ens.Config.DefaultSettings).%New()
Set setting.ProductionName = production
Set setting.ItemName = itemname
Set setting.HostClassName = hostclassname
Set setting.SettingName = settingname
Set setting.SettingValue = settingvalue
Set setting.Description = description
Set sc = setting.%Save()
Et pour récupérer les paramètres, appelez :
set sc = ##class(Ens.Config.DefaultSettings).%GetSetting(production, itemname, hostclassname, "", settingname, .settingvalue)
set settingvalue = ##class(Ens.Director).GetProductionSettingValue(production, settingname, .sc)
Les hôtes d'interopérabilité reçoivent leurs paramètres automatiquement au démarrage du travail de l'hôte commercial.
Making your application configurable when deploying to more than one server is essential. It can be pretty easy at the early part of the development cycle, but the costs rise with each hardcoded URL. InterSystems IRIS offers several tools you can use to configure the state of your application at startup.
How do you manage multiple deployments?