ECP Avec Docker
Salut la communauté,
Ceci est le troisième article de la série traitant sur l’initialisation d’instances IRIS avec Docker. Cette fois, on s’intéresse à Enterprise Cache Protocol (ECP).
De manière très simplifiée, ECP permet de configurer certaines instances IRIS avec le rôle de serveur d’applications et d’autres avec le rôle de serveur de données. Vous trouverez toutes les informations techniques détaillées dans la documentation officielle.
Le but de cet article est de décrire comment nous pouvons scripter l'initialisation d’un serveur de données, d’un ou plusieurs serveurs d’applications et d’établir une connexion cryptée entre ces nœuds avec Docker. Pour cela, nous utilisons certains outils déjà rencontrés dans les articles précédents traitant de la mise en miroir la webgateway tel que OpenSSL, envsubst et Config-API.
Prérequis
ECP n’est pas disponible dans la version IRIS Community. Il est donc nécessaire d’avoir un accès au World Response Center afin de pouvoir télécharger une licence “container” ainsi que pour se connecter au registry containers.intersystems.com.
Préparation du système
Le système doit partager certains fichiers locaux avec les containers. Il est donc nécessaire de créer certains utilisateurs et groupes afin d’éviter l’erreur “access denied”.
sudo useradd --uid 51773 --user-group irisowner
sudo useradd --uid 52773 --user-group irisuser
sudo groupmod --gid 51773 irisowner
sudo groupmod --gid 52773 irisuser
```bash
Si vous n’avez pas encore votre licence “iris.key”, téléchargez-là sur le WRC ensuite mettez-là dans votre répertoire home.
## Récupérer le repository d’exemple
Tous les fichiers dont vous avez besoin sont disponible sur un [repository public](https://github.com/lscalese/ecp-with-docker), commencez par le cloner:
```bash
git clone https://github.com/lscalese/ecp-with-docker.git
cd ecp-with-docker
Certificats SSL
Afin de crypter les communications entre les serveurs d’applications et le serveur de données, nous avons besoin de certificats SSL. Le script “gen-certificates.sh” prêt à l’emploi est disponible, toutefois, n’hésitez pas à le modifier pour que les paramètres des certificats soient cohérents avec votre localisation, compagnie, etc…
Exécutez:
sh ./gen-certificates.sh
Les certificats générés sont dans le répertoire “./certificates”.
Fichier | Container | Description |
---|---|---|
./certificates/CA_Server.cer | Serveur d’applications et serveur de données | Authority server certificate |
./certificates/app_server.cer | Serveur d’applications | Certificat pour l’instance IRIS |
./certificates/app_server.key | Serveur d’applications | Clé privée associée |
./certificates/data_server.cer | Serveur de données | Certificat pour l’instance IRIS |
./certificates/data_server.key | Serveur de données | Clé privée associée |
Construire l’image
Avant toute chose, loggez-vous au docker registry d’Intersystems. Lors de la construction, l’image de base sera téléchargée sur le registry:
docker login -u="YourWRCLogin" -p="YourICRToken" containers.intersystems.com
Si vous ne connaissez pas votre token, vous pouvez le récupérer sur cette page https://containers.intersystems.com en vous connectant avec votre compte WRC.
Lors de cette construction, nous allons ajouter à l’image de base de IRIS quelques logiciels utilitaires:
- gettext-base : qui permettra de substituer les variables d’environnements dans nos fichiers de configuration avec la commande “envsubst”.
- iputils-arping : qui est requis dans le cas ou l’on souhaite mettre le serveur de données en miroir.
- ZPM: gestionnaire de paquet ObjectScript.
ARG IMAGE=containers.intersystems.com/intersystems/iris:2022.2.0.281.0
# Don't need to download the image from WRC. It will be pulled from ICR at build time.
FROM $IMAGE
USER root
# Install iputils-arping to have an arping command. It's required to configure Virtual IP.
# Download the latest ZPM version (ZPM is included only with community edition).
RUN apt-get update && apt-get install iputils-arping gettext-base && \
rm -rf /var/lib/apt/lists/*
USER ${ISC_PACKAGE_MGRUSER}
WORKDIR /home/irisowner/demo
RUN --mount=type=bind,src=.,dst=. \
iris start IRIS && \
iris session IRIS < iris.script && \
iris stop IRIS quietly
Il n’y a rien de particulier dans ce Dockerfile, excepté la dernière ligne. Celle-ci configure l’instance IRIS serveur de données pour accepter jusqu’à 3 serveurs d’applications. Attention, cette configuration nécessite un redémarrage de IRIS. Nous affectons la valeur de ce paramètre pendant la construction afin d’éviter de devoir scripter un redémarrage plus tard.
Démarrez la construction:
docker-compose build –no-cache
Les fichiers de configurations
Pour la configuration des instances IRIS (serveurs d’applications et serveur de données) nous utilisons des fichiers format JSON config-api. Vous remarquerez que ceux-ci contiennent des variables d’environnements “${variable_name}”. Leurs valeurs sont définies dans les sections “environment” du fichier docker-compose.yml que nous verrons plus tard dans ce document. Ces variables seront substituées juste avant le chargement des fichiers à l’aide de l’utilitaire “envsubst”.
Serveur de données
Pour le serveur de données, nous allons:
- Activer le service ECP et définir la liste des clients autorisés (serveurs d’applications).
- Créer la configuration “SSL %ECPServer” nécessaire pour le cryptage des communications.
- Créer une base de données “myappdata”. Celle-ci sera utilisée comme base de données distante depuis les applications serveurs.
{
"Security.Services" : {
"%Service_ECP" : {
"Enabled" : true,
"ClientSystems":"${CLIENT_SYSTEMS}",
"AutheEnabled":"1024"
}
},
"Security.SSLConfigs": {
"%ECPServer": {
"CAFile": "${CA_ROOT}",
"CertificateFile": "${CA_SERVER}",
"Name": "%ECPServer",
"PrivateKeyFile": "${CA_PRIVATE_KEY}",
"Type": "1",
"VerifyPeer": 3
}
},
"Security.System": {
"SSLECPServer":1
},
"SYS.Databases":{
"/usr/irissys/mgr/myappdata/" : {}
},
"Databases":{
"myappdata" : {
"Directory" : "/usr/irissys/mgr/myappdata/"
}
}
}
Ce fichier de configuration est chargé au démarrage du container serveur de données par le script “init_datasrv.sh”. Tous les serveurs d’applications qui se connectent au serveur de données doivent être approuvés, ce script validera automatiquement toutes les connexions dans un délai de 100 secondes afin de limiter les actions manuelles dans le portail d’administration. Bien sûr, cela peut être amélioré pour renforcer la sécurité.
Serveur d’applications
Pour les serveurs d’applications, nous allons:
- Activer le service ECP.
- Créer la configuration SSL “%ECPClient” nécessaire pour le cryptage des communications.
- Configurer les informations de connexion au serveur de données.
- Créer la configuration de la base de données distante “myapp”
- Créer un mapping de globale “demo.*” dans le namespace “USER” a destination la base de données “myappdata”. Ceci nous permettra de tester le fonctionnement de ECP plus tard.
{
"Security.Services" : {
"%Service_ECP" : {
"Enabled" : true
}
},
"Security.SSLConfigs": {
"%ECPClient": {
"CAFile": "${CA_ROOT}",
"CertificateFile": "${CA_CLIENT}",
"Name": "%ECPClient",
"PrivateKeyFile": "${CA_PRIVATE_KEY}",
"Type": "0"
}
},
"ECPServers" : {
"${DATASERVER_NAME}" : {
"Name" : "${DATASERVER_NAME}",
"Address" : "${DATASERVER_IP}",
"Port" : "${DATASERVER_PORT}",
"SSLConfig" : "1"
}
},
"Databases": {
"myappdata" : {
"Directory" : "/usr/irissys/mgr/myappdata/",
"Name" : "${REMOTE_DB_NAME}",
"Server" : "${DATASERVER_NAME}"
}
},
"MapGlobals":{
"USER": [{
"Name" : "demo.*",
"Database" : "myappdata"
}]
}
}
Le fichier de configuration est chargé au démarrage d’un container serveur d’applications par le script “init_appsrv.sh”.
Démarrer les containers
Nous pouvons maintenant démarrer les containers:
- 2 serveurs d’applications.
- 1 serveur de données.
Pour cela, exécutez:
docker-compose up –scale ecp-demo-app-server=2
Voir le fichier docker-compose pour les détails:
# Les variables sont définies dans le fichier .env file
# Pour afficher le fichier de configuration résolu, exécutez :
# docker-compose config
version: '3.7'
services:
ecp-demo-data-server:
build: .
image: ecp-demo
container_name: ecp-demo-data-server
hostname: data-server
networks:
app_net:
environment:
# Liste des serveurs d’applications autorisés.
- CLIENT_SYSTEMS=ecp-with-docker_ecp-demo-app-server_1;ecp-with-docker_ecp-demo-app-server_2;ecp-with-docker_ecp-demo-app-server_3
# Chemin vers le certificat du serveur d’autorité.
- CA_ROOT=/certificates/CA_Server.cer
# Chemin vers le certificat du serveur de données
- CA_SERVER=/certificates/data_server.cer
# Chemin vers la clé privée du certificat du serveur de données
- CA_PRIVATE_KEY=/certificates/data_server.key
# Chemin vers le fichier de Configuration Config-API utilisé pour configurer cette instance
- IRIS_CONFIGAPI_FILE=/home/irisowner/demo/data-server.json
ports:
- "81:52773"
volumes:
# Post start script pour initialiser l’instance du serveur de données.
- ./init_datasrv.sh:/home/irisowner/demo/init_datasrv.sh
# Montage des certificats
- ./certificates/app_server.cer:/certificates/data_server.cer
- ./certificates/app_server.key:/certificates/data_server.key
- ./certificates/CA_Server.cer:/certificates/CA_Server.cer
# Montage du fichier de configuration Config-API
- ./config-files/data-server.json:/home/irisowner/demo/data-server.json
# Montage du fichier de licence IRIS
- ./iris.key:/dur/iris.key
command: -a /home/irisowner/demo/init_appsrv.sh
ecp-demo-app-server:
image: ecp-demo
networks:
app_net:
environment:
# Nom d’hôte ou adresse ip du serveur de données.
- DATASERVER_IP=data-server
- DATASERVER_NAME=data-server
- DATASERVER_PORT=1972
# Chemin vers le certificat du serveur d’autorité.
- CA_ROOT=/certificates/CA_Server.cer
# Chemin vers le certificat du serveur d’applications.
- CA_CLIENT=/certificates/app_server.cer
# Chemin vers la clé privée du certificat du serveur d’applications.
- CA_PRIVATE_KEY=/certificates/app_server.key
- IRIS_CONFIGAPI_FILE=/home/irisowner/demo/app-server.json
ports:
- 52773
volumes:
# Post start script pour initialiser l’instance du serveur de données.
- ./init_appsrv.sh:/home/irisowner/demo/init_appsrv.sh
# Montage des certificats.
- ./certificates/CA_Server.cer:/certificates/CA_Server.cer
- ./certificates/app_server.cer:/certificates/app_server.cer
- ./certificates/app_server.key:/certificates/app_server.key
# Montage du fichier de configuration Config-API.
- ./config-files/app-server.json:/home/irisowner/demo/app-server.json
# Montage du fichier de licence IRIS.
- ./iris.key:/dur/iris.key
command: -a /home/irisowner/demo/init_appsrv.sh
networks:
app_net:
ipam:
driver: default
config:
# APP_NET_SUBNET variable is defined in .env file
- subnet: "${APP_NET_SUBNET}"
Testons-le!
Accès au portail d’administration du serveur de données
Les containers sont démarrés, vérifions l’état à partir du serveur de données.
Le port 52773 est mappé sur le port local 81, vous pouvez donc y accéder avec cette adresse http://localhost:81/csp/sys/utilhome.csp.
Connectez-vous avec le login\password par défaut ensuite allez dans Système -> Configuration -> Params ECP. Cliquez sur “Serveurs d’application ECP”. Si tout fonctionne bien, vous devriez voir 2 serveurs d’applications avec le statut “Normal”. La structure du nom du client est "data server name":"application server hostname":"IRIS instance name". Dans notre cas, nous n’avons pas paramétré les hostnames des serveurs d’applications, nous avons donc des hostnames auto-générés.
Accès au portail d’administration des serveurs d’applications
Pour vous connecter au portail d’administration des serveurs d’applications, vous devez d’abord récupérer le numéro de port. Etant donné que nous avons utilisé l’option “--scale”, nous n’avons pas pu fixer les ports dans le fichier docker-compose. Il faut donc les retrouver à l’aide de la commande “docker ps”:
docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
a1844f38939f ecp-demo "/tini -- /iris-main…" 25 minutes ago Up 25 minutes (unhealthy) 1972/tcp, 2188/tcp, 53773/tcp, 54773/tcp, 0.0.0.0:81->52773/tcp, :::81->52773/tcp ecp-demo-data-server
4fa9623be1f8 ecp-demo "/tini -- /iris-main…" 25 minutes ago Up 25 minutes (unhealthy) 1972/tcp, 2188/tcp, 53773/tcp, 54773/tcp, 0.0.0.0:49170->52773/tcp, :::49170->52773/tcp ecp-with-docker_ecp-demo-app-server_1
ecff03aa62b6 ecp-demo "/tini -- /iris-main…" 25 minutes ago Up 25 minutes (unhealthy) 1972/tcp, 2188/tcp, 53773/tcp, 54773/tcp, 0.0.0.0:49169->52773/tcp, :::49169->52773/tcp ecp-with-docker_ecp-demo-app-server_2
Dans cet exemple, les ports sont:
- 49170 pour le premier serveur d’applications http://localhost:49170/csp/sys/utilhome.csp
- 49169 pour le second serveur d’applications http://localhost:49169/csp/sys/utilhome.csp
Test de lecture\écriture sur la base de données distante
Effectuons maintenant quelques tests de lecture\écriture en terminal.
Ouvrons un terminal IRIS sur le premier serveur d’applications:
docker exec -it ecp-with-docker_ecp-demo-app-server_1 iris session iris
Set ^demo.ecp=$zdt($h,3,1) _ “ écriture à partir du premier serveur d’applications”
Ouvrons maintenant un terminal sur le second serveur d’applications:
docker exec -it ecp-with-docker_ecp-demo-app-server_2 iris session iris
Set ^demo.ecp(2)=$zdt($h,3,1) _ " écriture à partir du second serveur d’applications."
zw ^demo.ecp
Vous devriez visualiser les écritures effectuées depuis les deux serveurs:
^demo.ecp(1)="2022-07-05 23:05:10 écriture à partir du premier serveur d’applications."
^demo.ecp(2)="2022-07-05 23:07:44 écriture à partir du second serveur d’applications."
Pour terminer, ouvrons un terminal IRIS sur le serveur de données et effectuons une lecture de la globale demo.ecp :
docker exec -it ecp-demo-data-server iris session iris
zw ^["^^/usr/irissys/mgr/myappdata/"]demo.ecp
^["^^/usr/irissys/mgr/myappdata/"]demo.ecp(1)="2022-07-05 23:05:10 écriture à partir du premier serveur d’applications."
^["^^/usr/irissys/mgr/myappdata/"]demo.ecp(2)="2022-07-05 23:07:44 écriture à partir du second serveur d’applications."
Voilà, c’est tout pour aujourd’hui, j’espère que cet article vous a plu. N’hésitez pas à laisser vos commentaires.