Coherence. Instalar Coherence Operator en OKE y configurar un cluster de Coherence.

Oracle Coherence es una opción muy potente cuando necesitamos un grid de datos en memoria con particionado, alta disponibilidad y escalado horizontal. Una forma cómoda de ejecutarlo en Kubernetes es mediante Coherence Operator, que se encarga de crear los recursos necesarios para levantar y operar los miembros del cluster.

En esta entrada vamos a desplegar un cluster de Coherence sobre Oracle Kubernetes Engine (OKE) usando Helm, una imagen propia con nuestro fichero cache-config.xml y un recurso declarativo de tipo Coherence.

Prerrequisitos

Para seguir la guía necesitamos:

Un cluster de OKE funcionando.
kubectl configurado contra ese cluster.
Helm 3 instalado.
Acceso a Oracle Cloud Infrastructure Registry, OCIR.
Una imagen de aplicación de Coherence o una imagen base sobre la que copiar nuestra configuración.

Crearé todos los recursos en el namespace coherencetest:

kubectl create namespace coherencetest

Secret para descargar imágenes desde OCIR

Si la imagen está en OCIR y el repositorio es privado, Kubernetes necesita un imagePullSecret. Ejemplo para la región Frankfurt:

kubectl create secret docker-registry ocirsecret \
  --namespace coherencetest \
  --docker-server=fra.ocir.io \
  --docker-username='<tenancy-namespace>/<usuario>' \
  --docker-password='<auth-token>' \
  --docker-email='<email>'

Notas importantes:

En OCIR se suele usar un Auth Token como contraseña.
El docker-server debe coincidir con la región donde publicarás la imagen, por ejemplo fra.ocir.io, iad.ocir.io o phx.ocir.io.
Si usas un usuario federado, revisa el formato exacto del usuario en la documentación de OCIR de tu tenancy.

Instalar Coherence Operator con Helm

Añadimos el repositorio de charts e instalamos el operator:

helm repo add coherence https://oracle.github.io/coherence-operator/charts
helm repo update

helm upgrade --install coherence-operator coherence/coherence-operator \
  --namespace coherencetest \
  --create-namespace

Comprobamos que el operator está levantado:

kubectl -n coherencetest get deployments
kubectl -n coherencetest get pods
kubectl get crd | grep coherence

Deberíamos ver un deployment del operator y el CRD que permite crear recursos Coherence.

Preparar la configuración de Coherence

Vamos a crear una caché distribuida muy sencilla. Guardamos este fichero como files/conf/storage-cache-config.xml:

<?xml version="1.0"?>
<cache-config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
              xmlns="http://xmlns.oracle.com/coherence/coherence-cache-config"
              xsi:schemaLocation="http://xmlns.oracle.com/coherence/coherence-cache-config coherence-cache-config.xsd">

  <caching-scheme-mapping>
    <cache-mapping>
      <cache-name>test*</cache-name>
      <scheme-name>distributed</scheme-name>
    </cache-mapping>
  </caching-scheme-mapping>

  <caching-schemes>
    <distributed-scheme>
      <scheme-name>distributed</scheme-name>
      <service-name>DistributedCache</service-name>
      <backing-map-scheme>
        <local-scheme/>
      </backing-map-scheme>
      <autostart>true</autostart>
    </distributed-scheme>
  </caching-schemes>
</cache-config>

Este ejemplo mapea cualquier caché que empiece por test a un esquema distribuido.

Crear una imagen de aplicación

El Operator despliega la imagen que indiquemos en spec.image. Por tanto, la imagen debe contener Coherence y nuestra configuración. Un Dockerfile genérico podría ser:

FROM <imagen-base-coherence-15c-o-14c>

COPY files/conf/ /app/conf/
COPY files/lib/  /app/lib/

Sustituye <imagen-base-coherence-15c-o-14c> por la imagen oficial o corporativa que uses en tu entorno. Lo importante es que storage-cache-config.xml quede en una ruta que esté en el classpath o que el runtime de Coherence pueda resolver.

Construimos, etiquetamos y publicamos en OCIR:

docker build -t coherence-demo:1.0.0 .

docker login fra.ocir.io

docker tag coherence-demo:1.0.0 \
  fra.ocir.io/<ocir-namespace>/coherence-demo:1.0.0

docker push fra.ocir.io/<ocir-namespace>/coherence-demo:1.0.0

En entornos reales, es preferible usar repositorios privados y imagePullSecrets.

Crear el cluster de Coherence

Guardamos este manifiesto como coherence-demo.yaml:

apiVersion: coherence.oracle.com/v1
kind: Coherence
metadata:
  name: coherence-demo
  namespace: coherencetest
spec:
  replicas: 3

  image: fra.ocir.io/<ocir-namespace>/coherence-demo:1.0.0
  imagePullSecrets:
    - name: ocirsecret

  jvm:
    memory:
      heapSize: 2g

  resources:
    requests:
      memory: "3Gi"
      cpu: "500m"
    limits:
      memory: "3Gi"
      cpu: "1"

  coherence:
    cacheConfig: storage-cache-config.xml
    storageEnabled: true

Lo desplegamos:

kubectl apply -f coherence-demo.yaml

Y comprobamos el estado:

kubectl -n coherencetest get coherence
kubectl -n coherencetest get pods
kubectl -n coherencetest get svc

El Operator creará los pods del cluster, un servicio headless para los miembros y los recursos auxiliares necesarios para que Coherence pueda descubrir los miembros del cluster dentro de Kubernetes.

Probar la caché

La forma exacta de probar dependerá de tu imagen. Si incluye la consola de Coherence, puedes entrar en uno de los pods:

kubectl -n coherencetest exec -it coherence-demo-0 -- bash

Desde dentro del contenedor, arranca la consola o tu cliente de prueba y valida que una entrada escrita en una caché se puede leer desde otro miembro.

Map (?): cache test1
Map (test1): put mykey myvalue
Map (test1): get mykey
myvalue
Map (test1): bye

Después entra en otro pod y comprueba que la clave sigue disponible:

kubectl -n coherencetest exec -it coherence-demo-1 -- bash

Map (?): cache test1
Map (test1): get mykey
myvalue
Map (test1): bye

Escalar el cluster

Podemos escalar el recurso Coherence con kubectl scale:

kubectl -n coherencetest scale coherence/coherence-demo --replicas=4

También podemos actualizar el campo spec.replicas:

kubectl -n coherencetest patch coherence coherence-demo --type merge \
  -p '{"spec":{"replicas":4}}'

Comprobamos el resultado:

kubectl -n coherencetest get pods
kubectl -n coherencetest get coherence coherence-demo

Nota sobre red en OKE

En Kubernetes conviene revisar siempre las reglas de red cuando un cluster necesita hablar entre pods, nodos o servicios. En OKE, presta especial atención a:

Network Security Groups o security lists de las subredes.
Network Policies dentro del cluster.
Reglas entre nodos si usas una configuración avanzada.
Puertos que expongas manualmente, sobre todo si añades un proxy Extend o gRPC.

Limpieza

Para borrar el cluster de Coherence:

kubectl -n coherencetest delete coherence coherence-demo

Para borrar también el Operator:

helm -n coherencetest uninstall coherence-operator

Conclusión

Con Coherence Operator podemos definir un cluster de Oracle Coherence de forma declarativa, versionar la configuración junto con la imagen y operar el despliegue con herramientas estándar de Kubernetes.

El flujo de trabajo queda así:

Crear una imagen con Coherence y la configuración de caché.
Publicarla en un registry privado, como OCIR.
Instalar Coherence Operator con Helm.
Crear un recurso Coherence con spec.image, spec.replicas y spec.coherence.cacheConfig.
Escalar y operar el cluster desde Kubernetes.

Enlaces útiles

Tagged with: OCI • OKE • Operator

PG&O