Historique
| Version | Date | Changements |
|---|
| V1 | 2022-02-08 | Version initiale |
| V1.1 | 2022-04-06 | Génération de certificats avec le fichier sh au lieu de pki-script
Utilisation de variables d'environnement dans des fichiers de configuration |
Salut, communauté,
Avez-vous déjà mis en place un environnement miroir ? Dispose-t-il d'un réseau privé, d'une adresse IP virtuelle et d'une configuration SSL ?
Après avoir fait cela plusieurs fois, je me suis rendu compte que c'est long, et qu'il y a beaucoup d'actions manuelles nécessaires pour générer des certificats et configurer chaque instance IRIS.
C'est une vraie casse-tête pour les personnes qui ont souvent à le faire.
Par exemple, une équipe d'assurance qualité peut avoir besoin de créer un nouvel environnement pour chaque nouvelle version d'application à tester. L'équipe de support peut avoir besoin de créer un environnement pour reproduire un problème complex.
Il faut absolument des outils pour les créer rapidement.
Dans cet article, nous allons créer un exemple pour configurer un miroir avec :
- Arbitre.
- Membre primaire.
- Membre de secours en cas de panne.
- Membre asynchrone de rapport en lecture-écriture.
- Configuration SSL pour les transferts de journaux entre les nœuds.
- Réseau privé pour le miroir.
- Adresse IP virtuelle.
- Une base de données en miroir.
À première vue, cela semble un peu complexe et nécessite beaucoup de code, mais ne vous inquiétez pas.
Il existe des bibliothèques hébergées sur OpenExchange pour effectuer facilement la plupart des opérations.
L'objectif de cet article est de fournir un exemple de manière à l'adapter à vos besoins, mais il ne s'agit pas d'un guide des meilleures pratiques en matière de sécurité.
Donc, créons notre sample.
Outils et bibliothèques
config-api: Cette bibliothèque sera utilisée pour configurer IRIS. Elle supporte la configuration du mirroring depuis la version 1.1.0. Nous ne donnerons pas une description détaillée de l'utilisation de cette bibliothèque. Un ensemble d'articles existe déjà. ici. En bref, config-api sera utilisé pour créer des fichiers de configuration (format JSON) et les charger facilement.
ZPM.
Docker.
OpenSSL.
Page Github
Vous pouvez trouver tous les fichiers de ressources nécessaires sur iris-mirroring-samples repository.
Préparation de votre système
Clonez le référentiel existant :
clone git https://github.com/lscalese/iris-mirroring-samples
cd iris-mirroring-samples
Si vous préférez créer un échantillon à partir de zéro, au lieu de cloner le référentiel, créez simplement un nouveau répertoire avec des sous-répertoires : backup, et config-files. Télécharger irissession.sh :
mkdir -p iris-mirroring-samples/backup iris-mirroring-samples/config-files
cd iris-mirroring-samples
wget -O session.sh https://raw.githubusercontent.com/lscalese/iris-mirroring-samples/master/session.sh
Pour éviter le problème "permission denied" plus tard, nous devons créer le groupe irisowner, l'utilisateur irisowner, et changer le groupe du répertoire backup en irisowner
sudo useradd --uid 51773 --user-group irisowner
sudo groupmod --gid 51773 irisowner
sudo chgrp irisowner ./backup
Ce répertoire sera utilisé comme volume pour partager une sauvegarde de la base de données après avoir configuré le premier membre miroir avec les autres nœuds.
Obtention d'une licence IRIS
La mise en miroir n'est pas disponible avec l'édition communautaire d'IRIS.
Si vous ne disposez pas encore d'une licence conteneur IRIS valide, connectez-vous au Centre de réponse mondial Worldwide Response Center (WRC) avec vos informations d'identification.
Cliquez sur "Actions" --> "Online distribtion" ("Actions" --> "Distribution en ligne"), puis sur le bouton "Evaluations" et sélectionnez "Evaluation License" ("Licence d'évaluation") ; remplissez le formulaire.
Copiez votre fichier de licence iris.key dans ce répertoire.
Connexion au Registre des conteneurs d'Intersystems
Pour des raisons pratiques, nous utilisons le Registre des conteneurs d'Intersystems (Intersystems Containers Registry) (ICR) pour extraire les images docker. Si vous ne connaissez pas votre login/mot de passe docker, connectez-vous simplement à SSO.UI.User.ApplicationTokens.cls avec vos informations d'identification WRC, et vous pourrez récupérer votre Token ICR.
docker login -u="YourWRCLogin" -p="YourICRToken" containers.intersystems.com
Création de la base de données myappdata et d'un mapping global
Nous ne créons pas vraiment la base de données myappdata maintenant mais préparons une configuration pour la créer au moment de la construction l'image.
Pour cela, nous créons juste un simple fichier au format JSON ;
La bibliothèque config-api sera utilisée pour le charger dans les instances IRIS.
Creation du ficher config-files/simple-config.json
{
"Defaults":{
"DBDATADIR" : "${MGRDIR}myappdata/",
"DBDATANAME" : "MYAPPDATA"
},
"SYS.Databases":{
"${DBDATADIR}" : {}
},
"Databases":{
"${DBDATANAME}" : {
"Directory" : "${DBDATADIR}"
}
},
"MapGlobals":{
"USER": [{
"Name" : "demo.*",
"Database" : "${DBDATANAME}"
}]
},
"Security.Services" : {
"%Service_Mirror" : { /* Activer le service miroir sur cette instance */
"Enabled" : true
}
}
}
Ce fichier de configuration vous permet de créer une nouvelle base de données avec les paramètres par défaut et de faire un global mapping demo.* dans l'espace de noms USER.
Pour plus d'informations sur les capacités du fichier de configuration config-api, consultez l'article ou la page github
Dockerfile
Le Dockerfile est basé sur le modèle existant docker template, mais nous devons faire quelques changements pour créer un répertoire de travail, installer les outils pour utiliser l'IP virtuelle, installer ZPM, etc…
Notre image IRIS est la même pour chaque membre du miroir. Le miroir sera mis en place sur le conteneur en commençant par la configuration correcte selon son rôle (primary, backup, ou report async r\w). Voir les commentaires sur le Dockerfile ci-dessous :
ARG IMAGE=containers.intersystems.com/intersystems/iris:2021.1.0.215.0
# Il n'est pas nécessaire de télécharger l'image depuis WRC. Elle sera tirée de l'ICR au moment de la construction.
FROM $IMAGE
USER root
COPY session.sh /
COPY iris.key /usr/irissys/mgr/iris.key
# /opt/demo sera notre répertoire de travail utilisé pour stocker nos fichiers de configuration et autres fichiers d'installation.
# Installez iputils-arping pour avoir une commande arping. Nécessaire pour configurer l'IP virtuelle.
# Téléchargez la dernière version de ZPM (ZPM est inclus uniquement dans l'édition communautaire).
RUN mkdir /opt/demo && \
chown ${ISC_PACKAGE_MGRUSER}:${ISC_PACKAGE_IRISGROUP} /opt/demo && \
chmod 666 /usr/irissys/mgr/iris.key && \
apt-get update && apt-get install iputils-arping gettext-base && \
wget -O /opt/demo/zpm.xml https://pm.community.intersystems.com/packages/zpm/latest/installer
USER ${ISC_PACKAGE_MGRUSER}
WORKDIR /opt/demo
# Définissez le rôle du miroir par défaut comme assistant.
# La valeur sera remplacée dans le fichier docker-compose au moment de l'exécution.
ARG IRIS_MIRROR_ROLE=master
# Copiez le contenu du répertoire config-files dans /opt/demo.
# Actuellement, nous n'avons créé qu'un simple-config pour configurer notre base de données et le mapping global.
# Plus tard dans cet article, nous ajouterons d'autres fichiers de configuration pour mettre en place le miroir.
ADD config-files .
SHELL [ "/session.sh" ]
# Installez ZPM
# Utilisez ZPM pour installer config-api
# Chargez le fichier simple-config.json avec config-api pour :
# - créer la base de données "myappdata",
# - ajouter un mapping global dans l'espace de nom "USER" pour la globale "demo.*" sur la base de données "myappdata".
# Fondamentalement, le point d'entrée pour installer votre application ObjectScript est ici.
# Pour cet exemple, nous allons charger simple-config.json pour créer une base de données simple et un mapping global.
RUN \
Do $SYSTEM.OBJ.Load("/opt/demo/zpm.xml", "ck") \
zpm "install config-api" \
Set sc = ##class(Api.Config.Services.Loader).Load("/opt/demo/simple-config.json")
# Copiez le script d'initialisation du miroir.
COPY init_mirror.sh /
Construction de l'image IRIS
Le Dockerfile est prêt ; nous pouvons construire l'image :
docker build --no-cache --tag mirror-demo:latest .
Cette image sera utilisée pour exécuter les nœuds primary, backup et de report async.
The .env file
Les fichiers de configuration JSON et docker-compose utilisent des variables d'environnement.
Leurs valeurs sont stockées dans un fichier nommé .env, pour ce sample notre fichier env est :
APP_NET_SUBNET=172.16.238.0/24
MIRROR_NET_SUBNET=172.16.220.0/24
IRIS_HOST=172.16.238.100
IRIS_PORT=1972
IRIS_VIRTUAL_IP=172.16.238.100
ARBITER_IP=172.16.238.10
MASTER_APP_NET_IP=172.16.238.20
MASTER_MIRROR_NET_IP=172.16.220.20
BACKUP_APP_NET_IP=172.16.238.30
BACKUP_MIRROR_NET_IP=172.16.220.30
REPORT_APP_NET_IP=172.16.238.40
REPORT_MIRROR_NET_IP=172.16.220.40
Préparation du fichier de configuration du premier membre du miroir
La bibliothèque config-api permet de configurer un miroir, nous devons donc créer un fichier de configuration dédié au premier membre du miroir : config-files/mirror-master.json
Pour plus de commodité, les commentaires sont situés directement dans le JSON. Vous pouvez télécharger le fichier [mirror-master.json sans commentaire ici] (https://raw.githubusercontent.com/lscalese/iris-mirroring-samples/master/config-files/mirror-master.json).
{
"Security.Services" : {
"%Service_Mirror" : {
"Enabled" : true
}
},
"SYS.MirrorMaster" : {
"Demo" : {
"Config" : {
"Name" : "Demo", /* Le nom de notre miroir */
"SystemName" : "master", /* Le nom de cette instance dans le miroir */
"UseSSL" : true,
"ArbiterNode" : "${ARBITER_IP}|2188", /* L'adresse IP et port du nœud arbitre */
"VirtualAddress" : "${IRIS_VIRTUAL_IP}/24", /* L'adresse IP virtuelle */
"VirtualAddressInterface" : "eth0", /* L'interface réseau utilisée pour l'adresse IP virtuelle. */
"MirrorAddress": "${MASTER_MIRROR_NET_IP}", /* L'adresse IP de ce noeud dans le réseau miroir privé */
"AgentAddress": "${MASTER_APP_NET_IP}" /* L'adresse IP de ce nœud (l'agent est installé sur la même machine) */
},
"Databases" : [{ /* La liste des bases de données à ajouter au miroir */
"Directory" : "/usr/irissys/mgr/myappdata/",
"MirrorDBName" : "MYAPPDATA"
}],
"SSLInfo" : { /* SSL Configuration */
"CAFile" : "/certificates/CA_Server.cer",
"CertificateFile" : "/certificates/master_server.cer",
"PrivateKeyFile" : "/certificates/master_server.key",
"PrivateKeyPassword" : "",
"PrivateKeyType" : "2"
}
}
}
}
Préparer le fichier de configuration du membre de basculement
Créer un fichier de configuration pour le membre backup (basculement) config-files/mirror-backup.json.
Le fichier est fort ressemblant au fichier de configuration du membre primary:
{
"Security.Services" : {
"%Service_Mirror" : {
"Enabled" : true
}
},
"SYS.MirrorFailOver" : {
"Demo" : { /* Le miroir à rejoindre */
"Config": {
"Name" : "Demo",
"SystemName" : "backup", /* Le nom de cette instance dans le miroir */
"InstanceName" : "IRIS", /* Le nom de l'instance IRIS du premier membre du miroir */
"AgentAddress" : "${MASTER_APP_NET_IP}", /* L'adresse IP de l'agent du premier membre du miroir */
"AgentPort" : "2188",
"AsyncMember" : false,
"AsyncMemberType" : ""
},
"Databases" : [{ /* DB dans le miroir */
"Directory" : "/usr/irissys/mgr/myappdata/"
}],
"LocalInfo" : {
"VirtualAddressInterface" : "eth0", /* L'interface réseau utilisée pour l'adresse IP virtuelle */
"MirrorAddress": "${BACKUP_MIRROR_NET_IP}" /* L'adresse IP de ce noeud dans le réseau miroir privé */
},
"SSLInfo" : {
"CAFile" : "/certificates/CA_Server.cer",
"CertificateFile" : "/certificates/backup_server.cer",
"PrivateKeyFile" : "/certificates/backup_server.key",
"PrivateKeyPassword" : "",
"PrivateKeyType" : "2"
}
}
}
}
Préparation du fichier de configuration des membres asynchrones en lecture-écriture
Il est assez similaire au fichier de configuration de basculement backup. Les différences sont les valeurs de AsyncMember, AsyncMemberType, et MirrorAddress.
Créez le fichier ./config-files/mirror-report.json :
{
"Security.Services" : {
"%Service_Mirror" : {
"Enabled" : true
}
},
"SYS.MirrorFailOver" : {
"Demo" : {
"Config": {
"Name" : "Demo",
"SystemName" : "report",
"InstanceName" : "IRIS",
"AgentAddress" : "${MASTER_APP_NET_IP}",
"AgentPort" : "2188",
"AsyncMember" : true,
"AsyncMemberType" : "rw"
},
"Databases" : [{
"Directory" : "/usr/irissys/mgr/myappdata/"
}],
"LocalInfo" : {
"VirtualAddressInterface" : "eth0",
"MirrorAddress": "${REPORT_MIRROR_NET_IP}"
},
"SSLInfo" : {
"CAFile" : "/certificates/CA_Server.cer",
"CertificateFile" : "/certificates/report_server.cer",
"PrivateKeyFile" : "/certificates/report_server.key",
"PrivateKeyPassword" : "",
"PrivateKeyType" : "2"
}
}
}
}
Génération des certificats et configuration des nœuds IRIS et
Tous les fichiers de configuration sont prêts !
Maintenant nous devons ajouter un script pour générer des certificats afin de sécuriser la communication entre chaque nœud. Un script prêt à l'emploi est disponible dans le repository gen-certificates.sh
# sudo est nécessaire en raison de l'utilisation de chown, chgrp chmod.
sudo ./gen-certificates.sh
Pour configurer chaque nœud, init_mirror.sh sera exécuté au démarrage des conteneurs. Il sera configuré plus tard dans docker-compose.yml dans la section commande command : ["-a", "/init_mirror.sh"] :
#!/bin/bash
# Base de données utilisée pour tester le miroir.
DATABASE=/usr/irissys/mgr/myappdata
# Répertoire contenant mes données d'application sauvegardées par l'assistant pour les restaurer sur les autres nœuds et en faire un miroir.
BACKUP_FOLDER=/opt/backup
# Fichier de configuration miroir au format json config-api pour le nœud d'assistant.
MASTER_CONFIG=/opt/demo/mirror-master.json
# Fichier de configuration miroir au format json config-api pour le nœud de sauvegarde.
BACKUP_CONFIG=/opt/demo/mirror-backup.json
# Fichier de configuration miroir au format json config-api pour le nœud asynchrone de rapport.
REPORT_CONFIG=/opt/demo/mirror-report.json
# Nom du miroir...
MIRROR_NAME=DEMO
# Liste des membres du miroir.
MIRROR_MEMBERS=BACKUP,REPORT
# Chargement de la configuration du miroir en utilisant config-api avec le fichier /opt/demo/simple-config.json.
# Démarrage d'une tâche Job pour accepter automatiquement d'autres membres nommés "backup" et "report" pour rejoindre le miroir (éviter la validation manuelle dans la gestion du portail).
master() {
rm -rf $BACKUP_FOLDER/IRIS.DAT
envsubst < ${MASTER_CONFIG} > ${MASTER_CONFIG}.resolved
iris session $ISC_PACKAGE_INSTANCENAME -U %SYS <<- END
Set sc = ##class(Api.Config.Services.Loader).Load("${MASTER_CONFIG}.resolved")
Set ^log.mirrorconfig(\$i(^log.mirrorconfig)) = \$SYSTEM.Status.GetOneErrorText(sc)
Job ##class(Api.Config.Services.SYS.MirrorMaster).AuthorizeNewMembers("${MIRROR_MEMBERS}","${MIRROR_NAME}",600)
Hang 2
Halt
END
}
make_backup() {
iris session $ISC_PACKAGE_INSTANCENAME -U %SYS "##class(SYS.Database).DismountDatabase(\"${DATABASE}\")"
md5sum ${DATABASE}/IRIS.DAT
cp ${DATABASE}/IRIS.DAT ${BACKUP_FOLDER}/IRIS.TMP
mv ${BACKUP_FOLDER}/IRIS.TMP ${BACKUP_FOLDER}/IRIS.DAT
chmod 777 ${BACKUP_FOLDER}/IRIS.DAT
iris session $ISC_PACKAGE_INSTANCENAME -U %SYS "##class(SYS.Database).MountDatabase(\"${DATABASE}\")"
}
# Restauration de la base de données miroir "myappdata". Cette restauration est effectuée sur le noeud "backup" et "report".
restore_backup() {
sleep 5
while [ ! -f $BACKUP_FOLDER/IRIS.DAT ]; do sleep 1; done
sleep 2
iris session $ISC_PACKAGE_INSTANCENAME -U %SYS "##class(SYS.Database).DismountDatabase(\"${DATABASE}\")"
cp $BACKUP_FOLDER/IRIS.DAT $DATABASE/IRIS.DAT
md5sum $DATABASE/IRIS.DAT
iris session $ISC_PACKAGE_INSTANCENAME -U %SYS "##class(SYS.Database).MountDatabase(\"${DATABASE}\")"
}
# Configuration du membre "backup"
# - Chargement du fichier de configuration /opt/demo/mirror-backup.json si cette instance est le backup ou
# /opt/demo/mirror-report.json si cette instance est le rapport (nœud miroir asynchrone R\W).
other_node() {
sleep 5
envsubst < $1 > $1.resolved
iris session $ISC_PACKAGE_INSTANCENAME -U %SYS <<- END
Set sc = ##class(Api.Config.Services.Loader).Load("$1.resolved")
Halt
END
}
if [ "$IRIS_MIRROR_ROLE" == "master" ]
then
master
make_backup
elif [ "$IRIS_MIRROR_ROLE" == "backup" ]
then
restore_backup
other_node $BACKUP_CONFIG
else
restore_backup
other_node $REPORT_CONFIG
fi
exit 0
Fichier Docker-compose
Nous avons quatre conteneurs pour commencer. Un fichier Docker-compose est parfait pour orchestrer notre sample.
version: '3.7'
services:
arbitre:
image: containers.intersystems.com/intersystems/arbiter:2021.1.0.215.0
init: true
container_name: mirror-demo-arbiter
commande:
- /usr/local/etc/irissys/startISCAgent.sh 2188
réseaux:
app_net:
ipv4_address: ${ARBITER_IP}
extra_hosts:
- "master:${MASTER_APP_NET_IP}"
- "backup:${BACKUP_APP_NET_IP}"
- "report:${REPORT_APP_NET_IP}"
cap_add:
- NET_ADMIN
assistant:
construction: .
image: mirror-demo
container_name: mirror-demo-master
réseaux:
app_net:
ipv4_address: ${MASTER_APP_NET_IP}
mirror_net:
ipv4_address: ${MASTER_MIRROR_NET_IP}
environnement:
- IRIS_MIRROR_ROLE=master
- WEBGATEWAY_IP=${WEBGATEWAY_IP}
- MASTER_APP_NET_IP=${MASTER_APP_NET_IP}
- MASTER_MIRROR_NET_IP=${MASTER_MIRROR_NET_IP}
- ARBITER_IP=${ARBITER_IP}
- IRIS_VIRTUAL_IP=${IRIS_VIRTUAL_IP}
ports:
- 81:52773
volumes:
- ./backup:/opt/backup
- ./init_mirror.sh:/init_mirror.sh
# Montage des certificats
- ./certificates/master_server.cer:/certificates/master_server.cer
- ./certificates/master_server.key:/certificates/master_server.key
- ./certificates/CA_Server.cer:/certificates/CA_Server.cer
#- ~/iris.key:/usr/irissys/mgr/iris.key
nom de l'hôte: master
extra_hosts:
- "backup:${BACKUP_APP_NET_IP}"
- "report:${REPORT_APP_NET_IP}"
cap_add:
- NET_ADMIN
commande: ["-a", "/init_mirror.sh"]
sauvegarde:
image: mirror-demo
container_name: mirror-demo-backup
réseaux:
app_net:
ipv4_address: ${BACKUP_APP_NET_IP}
mirror_net:
ipv4_address: ${BACKUP_MIRROR_NET_IP}
ports:
- 82:52773
environnement :
- IRIS_MIRROR_ROLE=backup
- WEBGATEWAY_IP=${WEBGATEWAY_IP}
- BACKUP_MIRROR_NET_IP=${BACKUP_MIRROR_NET_IP}
- MASTER_APP_NET_IP=${MASTER_APP_NET_IP}
- BACKUP_APP_NET_IP=${BACKUP_APP_NET_IP}
volumes:
- ./backup:/opt/backup
- ./init_mirror.sh:/init_mirror.sh
# Montage des certificats
- ./certificates/backup_server.cer:/certificates/backup_server.cer
- ./certificates/backup_server.key:/certificates/backup_server.key
- ./certificates/CA_Server.cer:/certificates/CA_Server.cer
#- ~/iris.key:/usr/irissys/mgr/iris.key
nom de l'hôte: backup
extra_hosts:
- "master:${MASTER_APP_NET_IP}"
- "report:${REPORT_APP_NET_IP}"
cap_add:
- NET_ADMIN
commande: ["-a", "/init_mirror.sh"]
rapport :
image: mirror-demo
container_name: mirror-demo-report
réseaux:
app_net:
ipv4_address: ${REPORT_APP_NET_IP}
mirror_net:
ipv4_address: ${REPORT_MIRROR_NET_IP}
ports:
- 83:52773
environnement :
- IRIS_MIRROR_ROLE=report
- WEBGATEWAY_IP=${WEBGATEWAY_IP}
- MASTER_APP_NET_IP=${MASTER_APP_NET_IP}
- REPORT_MIRROR_NET_IP=${REPORT_MIRROR_NET_IP}
- REPORT_APP_NET_IP=${REPORT_APP_NET_IP}
volumes:
- ./backup:/opt/backup
- ./init_mirror.sh:/init_mirror.sh
# Montage des certificats
- ./certificates/report_server.cer:/certificates/report_server.cer
- ./certificates/report_server.key:/certificates/report_server.key
- ./certificates/CA_Server.cer:/certificates/CA_Server.cer
#- ~/iris.key:/usr/irissys/mgr/iris.key
nom de l'hôte: report
extra_hosts:
- "master:${MASTER_APP_NET_IP}"
- "backup:${BACKUP_APP_NET_IP}"
cap_add:
- NET_ADMIN
commande: ["-a", "/init_mirror.sh"]
réseaux:
app_net:
ipam:
driver: default
config:
- subnet: "${APP_NET_SUBNET}"
mirror_net:
ipam:
driver: default
config:
- subnet: "${MIRROR_NET_SUBNET}"
Le fichier docker-compose.yml contient beaucoup de variables d'environnement. Pour voir le fichier résolu, tapez dans le terminal :
docker-compose config
Exécuter des conteneurs
docker-compose up
Attendez que chaque instance ait un statut de miroir correct :
- nœud primary avec le statut
Primary. - nœud backup avec le statut
Backup. - noeud report avec le statut
Connected.
Enfin, vous devriez voir ces messages dans les journaux de docker :
mirror-demo-master | 01/09/22-11:02:08:227 (684) 1 [Utility.Event] Devient le serveur miroir primaire
...
mirror-demo-backup | 01/09/22-11:03:06:398 (801) 0 [Utility.Event] Trouver MASTER comme primaire, devenant sauvegarde
...
mirror-demo-report | 01/09/22-11:03:10:745 (736) 0 [Generic.Event] MirrorClient : Connecté au primaire : MASTER (ver 4)
Vous pouvez aussi vérifier l'état du miroir avec le portail http://localhost:81/csp/sys/utilhome.csp
Accès aux portails
Dans Docker-compose, nous mappons les ports 81, 82 et 83 pour avoir un accès à chaque portail de gestion.
Il s'agit du login/mot de passe par défaut pour toutes les instances :
Test
Vérifiez le moniteur miroir (portail de gestion ; il s'agit de l'utilisateur et du mot de passe par défaut) : http://localhost:81/csp/sys/op/%25CSP.UI.Portal.Mirror.Monitor.zen
Vérifiez les paramètres du miroir : http://localhost:81/csp/sys/mgr/%25CSP.UI.Portal.Mirror.EditFailover.zen?$NAMESPACE=%25SYS
Nous pouvons démarrer un test en configurant simplement une globale commençant par demo.
Rappelez-vous que nous avons configuré un mapping global demo.* sur l'espace de nom USER.
Ouvrez une session de terminal sur le serveur primaire :
docker exec -it mirror-demo-master irissession iris
Set ^demo.test = $zdt($h,3,1)
Vérifiez si les données sont disponibles sur le nœud de sauvegarde :
docker exec -it mirror-demo-backup irissession iris
Write ^demo.test
Vérifiez si les données sont disponibles sur le nœud de rapport ::
docker exec -it mirror-demo-report irissession iris
Write ^demo.test
Bien ! Nous avons un environnement miroir prêt, entièrement créé par programmation.
Pour que ce soit un peu plus complet, il faudrait ajouter une passerelle web avec https et un cryptage entre la passerelle web et IRIS, mais nous allons laisser cela pour le prochain article.
Nous espérons que cet article vous sera utile si vous décidez de créer votre propre script
Source
Le contenu de cet article est inspiré par :
