ECP con Docker

¡Hola Comunidad!

Este es el tercer artículo de la serie sobre arranque de instancias de IRIS con Docker. En esta publicación nos centraremos en el Enterprise Caché Protocol (ECP) o Protocolo de Caché Empresarial.

De manera muy simplificada, ECP permite configurar algunas instancias de IRIS como servidores de aplicaciones y otras como servidores de datos. Encontraréis más información técnica detallada en la documentación oficial.

El objetivo de este artículo es describir:

• Cómo escribir el script de arranque de un servidor de datos y de uno o más servidores de aplicaciones.
• Cómo establecer una conexión cifrada entre estos nodos con Docker.

Para hacerlo, generalmente utilizamos algunas de las herramientas que ya hemos visto en artículos anteriores sobre web gateway y mirroring, que describen instrumentos como OpenSSL, envsubst y Config-API.

Requisitos

ECP no está disponible en la versión Community de IRIS. Por lo tanto, se requiere acceso al World Response Center (WRC) para descargar una licencia de contenedor y conectarse al registro de contenedores en containers.intersystems.com.

Preparando el sistema

El sistema debe compartir algunos archivos locales con los contenedores. Es necesario crear ciertos usuarios y grupos para evitar el error "access denied" (acceso denegado).

sudo useradd --uid 51773 --user-group irisowner
sudo useradd --uid 52773 --user-group irisuser
sudo groupmod --gid 51773 irisowner
sudo groupmod --gid 52773 irisuser

Si aún no tenéis la licencia "iris.key", podéis descargarla desde el WRC y añadirla a vuestro directorio principal.

Obtener el repositorio de muestra

Todos los archivos que se necesitan están disponibles en un repositorio público, excepto la licencia "iris.key", así que hay que comenzar clonándola:

git clone https://github.com/lscalese/ecp-with-docker.git
cd ecp-with-docker

Certificados SSL

Para encriptar las comunicaciones entre los servidores de aplicaciones y el servidor de datos, necesitamos certificados SSL. Un script listo para usar ("gen-certificates.sh") está disponible. Sin embargo, podéis modificarlo libremente para que los ajustes del certificado sean consistentes con vuestra ubicación, empresa, etc.

Ejecutad:

sh ./gen-certificates.sh

Los certificados generados ahora se encuentran en el directorio "./certificates".

Archivo	Contenedor	Descripción
./certificates/CA_Server.cer	Servidor de aplicaciones y servidor de datos	Certificado del servidor de autoridad
./certificates/app_server.cer	Servidor de aplicaciones	Certificado para la instancia del servidor de aplicaciones de IRIS
./certificates/app_server.key	Servidor de aplicaciones	Clave privada correspondiente
./certificates/data_server.cer	Servidor de datos	Certificado para la instancia del servidor de datos de IRIS
./certificates/data_server.key	Servidor de datos	Clave privada correspondiente

Construcción de la imagen

En primer lugar, iniciad sesión en el registro de Docker de InterSystems. La imagen base se descargará del registro durante la ejecución del comando build:

docker login -u="YourWRCLogin" -p="YourICRToken" containers.intersystems.com

Si no conocéis vuestro token, iniciad sesión en https://containers.intersystems.com/ con vuestra cuenta del WRC.

Durante la ejecución del build, añadiremos algunas utilidades de software a la imagen base de IRIS:

• gettext-base: nos permitirá sustituir variables de entorno en nuestros archivos de configuración utilizando el comando "envsubst".
• iputils-arping: se requiere en caso de que queramos hacer un mirror del servidor de datos.
• ZPM: administrador de paquetes de ObjectScript.

Dockerfile:

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

No hay nada especial en este Dockerfile, excepto la última línea. Configura la instancia del servidor de datos de IRIS para aceptar hasta 3 servidores de aplicaciones. Tened en cuenta que esta configuración requiere reiniciar IRIS. Asignamos el valor de este parámetro durante la ejecución del comando build para evitar tener que reiniciar posteriormente.

Ejecutar el comando build:

docker-compose build –no-cache

Archivos de configuración

Para la configuración de las instancias de IRIS (servidores de aplicaciones y servidor de datos), utilizamos el formato JSON del archivo Config-API. Notaréis que estos archivos contienen variables de entorno "${variable_name}". Sus valores se definen en las secciones "environment" del archivo "docker-compose.yml" que veremos más adelante en este documento. Estas variables se sustituirán justo antes de cargar los archivos utilizando la utilidad "envsubst".

Servidor de datos

Para el servidor de datos, haremos lo siguiente:

• Habilitar el servicio ECP y definir la lista de clientes autorizados (servidores de aplicaciones).
• Crear la configuración "SSL %ECPServer" necesaria para encriptar las comunicaciones.
• Crear una base de datos llamada "myappdata". Esta base de datos se utilizará como base de datos remota desde los servidores de aplicaciones.

(data-serer.json)[https://github.com/lscalese/ecp-with-docker/blob/master/config-files/dat...

{
   "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/"
       }
   }
}

Este archivo de configuración se carga al inicio del contenedor del servidor de datos mediante el script "init_datasrv.sh". Todos los servidores de aplicaciones conectados al servidor de datos deben ser confiables. Este script validará automáticamente todas las conexiones dentro de los 100 segundos para limitar las acciones manuales en el portal de administración. Por supuesto, esto se puede mejorar para aumentar la seguridad.

Servidor de aplicaciones

Para los servidores de aplicaciones, realizaremos lo siguiente:

• Habilitar el servicio ECP.
• Crear la configuración SSL "%ECPClient" requerida para el cifrado de la comunicación.
• Configurar la información de conexión con el servidor de datos.
• Crear la configuración de la base de datos remota "myappdata".
• Crear un mapeo global "demo.*" en el namespace "USER" hacia la base de datos "myappdata". Esto nos permitirá probar el funcionamiento de ECP posteriormente.

app-server.json:

{
   "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"
       }]
   }
}

El archivo de configuración se carga al iniciar un contenedor del servidor de aplicaciones mediante el script "init_appsrv.sh".

Iniciar los contenedores

Ahora podemos iniciar los contenedores:

• 2 servidores de aplicaciones.
• 1 servidor de datos.

Para hacer esto, hay que ejecutar:

docker-compose up –scale ecp-demo-app-server=2

Podéis consultar el archivo docker-compose para obtener más detalles:

# Variables are defined in .env file
# to show the resolved docker-compose file, execute
# 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:
     # List of allowed ECP clients (application server). 
     - 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
     # Path authority server certificate
     - CA_ROOT=/certificates/CA_Server.cer
     # Path to data server certificate
     - CA_SERVER=/certificates/data_server.cer
     # Path to private key of the data server certificate
     - CA_PRIVATE_KEY=/certificates/data_server.key
     # Path to Config-API file to initiliaze this IRIS instance
     - IRIS_CONFIGAPI_FILE=/home/irisowner/demo/data-server.json
   ports:
     - "81:52773"
   volumes:
     # Post start script - data server initilization.
     - ./init_datasrv.sh:/home/irisowner/demo/init_datasrv.sh
     # Mount certificates (see gen-certificates.sh to generate certificates)
     - ./certificates/app_server.cer:/certificates/data_server.cer
     - ./certificates/app_server.key:/certificates/data_server.key
     - ./certificates/CA_Server.cer:/certificates/CA_Server.cer
     # Mount config file
     - ./config-files/data-server.json:/home/irisowner/demo/data-server.json
     # IRIS License
     - ~/iris.key:/usr/irissys/mgr/iris.key
   command: -a /home/irisowner/demo/init_datasrv.sh


 ecp-demo-app-server:
   image: ecp-demo
   networks:
     app_net:
   environment:
     # Hostname or IP of the data server.
     - DATASERVER_IP=data-server
     - DATASERVER_NAME=data-server
     - DATASERVER_PORT=1972
     # Path authority server certificate
     - CA_ROOT=/certificates/CA_Server.cer
     - CA_CLIENT=/certificates/app_server.cer
     - CA_PRIVATE_KEY=/certificates/app_server.key
     - IRIS_CONFIGAPI_FILE=/home/irisowner/demo/app-server.json
   ports:
     - 52773
   volumes:
     # Post start script - application server initilization.
     - ./init_appsrv.sh:/home/irisowner/demo/init_appsrv.sh
     # Mount certificates
     - ./certificates/CA_Server.cer:/certificates/CA_Server.cer
     # Path to private key of the data server certificate
     - ./certificates/app_server.cer:/certificates/app_server.cer
     # Path to private key of the data server certificate
     - ./certificates/app_server.key:/certificates/app_server.key
     # Path to Config-API file to initiliaze this IRIS instance
     - ./config-files/app-server.json:/home/irisowner/demo/app-server.json
     # IRIS License
     - ~/iris.key:/usr/irissys/mgr/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}"

¡Vamos a probarlo!

Acceso al portal de administración del servidor de datos

Los contenedores se han iniciado. Vamos a verificar el estado desde el servidor de datos.
El puerto 52773 está mapeado al puerto local 81, por lo que se puede acceder a él con esta dirección http://localhost:81/csp/sys/utilhome.csp.

Iniciad sesión con el nombre de usuario y contraseña predeterminados, luego hay que ir a System -> Configuration -> ECP Params. Haced clic en "ECP Application Servers". Si todo funciona correctamente, deberíais ver 2 servidores de aplicaciones con el estado "Normal". La estructura del nombre del cliente es "data server name":"application server hostname":"IRIS instance name". En nuestro caso, no hemos configurado los nombres de los servidores de aplicaciones, por lo que se han generado automáticamente.

Acceder al portal de administración del servidor de aplicaciones

Para conectarse al portal de administración de los servidores de aplicaciones, hay que obtener el número de puerto. Como utilizamos la opción "--scale", no pudimos establecer los puertos en el archivo docker-compose. Por lo tanto, hay que recuperarlos con el comando 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

En este ejemplo, los puertos son:

• 49170 para el primer servidor de aplicaciones: http://localhost:49170/csp/sys/utilhome.csp
• 49169 para el segundo servidor de aplicaciones: http://localhost:49169/csp/sys/utilhome.csp

Pruebas de lectura/escritura en la base de datos remota.

Vamos a realizar unas pruebas de lectura/escritura en el terminal.
Abrid una terminal de IRIS en el primer servidor de aplicaciones:

docker exec -it ecp-with-docker_ecp-demo-app-server_1 iris session iris
Set ^demo.ecp=$zdt($h,3,1) _ “ write from the first application server.”

Ahora abrid una terminal en el segundo servidor de aplicaciones:

docker exec -it ecp-with-docker_ecp-demo-app-server_2 iris session iris
Set ^demo.ecp(2)=$zdt($h,3,1) _ " write from the second application server."
zwrite ^demo.ecp

Deberíais ver las respuestas de ambos servidores:

^demo.ecp(1)="2022-07-05 23:05:10 write from the first application server."
^demo.ecp(2)="2022-07-05 23:07:44 write from the second application server."

Finalmente, abrid una terminal de IRIS en el servidor de datos y realizad una lectura del global demo.ecp:

docker exec -it ecp-demo-data-server iris session iris
zwrite ^["^^/usr/irissys/mgr/myappdata/"]demo.ecp

^["^^/usr/irissys/mgr/myappdata/"]demo.ecp(1)="2022-07-05 23:05:10 write from the first application server."
^["^^/usr/irissys/mgr/myappdata/"]demo.ecp(2)="2022-07-05 23:07:44 write from the second application server."

Eso es todo por hoy. Espero que os haya gustado este artículo. No dudéis en dejar un comentario si tenéis alguna duda o consulta.