Installing on Kubernetes

GridGain is tested on Kubernetes version 1.26.

1. Create the GridGain configuration file and get a license. The minimum node configuration is as follows:

   gridgain-config.conf

   ignite: {
    network: {
    # GridGain 9 node port
    port = 3344
    nodeFinder = {
    netClusterNodes = [
    # Kubernetes service to access the GridGain 9 cluster on the Kubernetes network
    "gridgain-svc-headless:3344"
    ]
    }
    }
    storage: {
    profiles = [
    {
    engine = "aipersist"
    name = "default"
    replacementMode = "CLOCK"
    # Explicit storage size configuration
    sizeBytes = 2147483648
    }
    ]
    }
   }

2. Place your license content in the license.conf file.

3. Create the ConfigMap object for GridGain configuration:

   kubectl create configmap gridgain-config -n <namespace> --from-file=gridgain-config.conf

4. Create the ConfigMap object for the GridGain license:

   kubectl create configmap gridgain-license -n <namespace> --from-file=license.conf

   Replace <namespace> with the name of the namespace where you want to deploy GridGain.

   To update GridGain node configuration, modify the existing ConfigMap and restart all GridGain pods.

   • Modify previously configured ConfigMap object:

     kubectl edit configmap gridgain-config -n <namespace>

   • Restart GridGain pod, repeat for every pod:

     kubectl delete pod <GridGain pode name> -n <namespace>

In Kubernetes deployments all environment variables must be defined directly in the container specification, either in the StatefulSet manifests or in the Helm chart configuration.

To configure JVM options (such as heap size, Metaspace, and Java agent), define the GRIDGAIN9_EXTRA_JVM_ARGS environment variable in your manifests.

For example, in a StatefulSet:

When using the Helm chart, define the same variable through the extraEnvVars field:

To generate JVM diagnostic files inside Kubernetes/Docker, pass the relevant JVM options through GRIDGAIN9_EXTRA_JVM_ARGS:

Ensure that the output directories exist and are writable inside the pod. Declare persistent volumes for diagnostic outputs and mount them into the container:

By default, the Docker image ships with a gridgain.java.util.logging.properties configuration that enables only console logging.

To modify the default logging behavior (e.g., enabling file-based logging or using log4j2), create a ConfigMap with a custom gridgain.java.util.logging.properties file and mount it into each pod.

• Create the ConfigMap:

• Mount it in the StatefulSet:

If you use Helm, the same can be defined via configMaps in values.yaml:

Once both are configured, directory—file logging becomes active on startup.

In Kubernetes deployments, the default storage profile is defined in the ConfigMap created during installation.

• You can use this configuration:

  storage: {
   profiles = [
   {
   engine = "aipersist"
   name = "default"
   replacementMode = "CLOCK"
   sizeBytes = 2147483648
   }
   ]
  }

• Or see the example on how to redefine it for the Helm chart.

Depending on your requirements, define and deploy a Kubernetes service. Gridgain 9 use two types of services: one for internal cluster discovery, and the other — for external client access.

1. First, choose a type of service you need and prepare the service.yaml file.

   • For communication inside the Kubernetes cluster, Use a headless service by setting the clusterIP parameter to None. This will expose each pod’s IP, enabling GridGain to be partition‐aware: clients discover every node’s address, determine which partition resides on which node, and send requests directly where the data is located.

   service.yaml

   apiVersion: v1
   kind: Service
   metadata:
    # The name must be equal to netClusterNodes.
    name: gridgain-svc-headless
    # Place your namespace name here.
    namespace: <namespace>
   spec:
    clusterIP: None
    internalTrafficPolicy: Cluster
    ipFamilies:
    - IPv4
    ipFamilyPolicy: SingleStack
    ports:
    - name: management
    port: 10300
    protocol: TCP
    targetPort: 10300
    - name: rest
    port: 10800
    protocol: TCP
    targetPort: 10800
    - name: cluster
    port: 3344
    protocol: TCP
    targetPort: 3344
    selector:
    # Must be equal to the label set for pods.
    app: gridgain
    # Include not-yet-ready nodes.
    publishNotReadyAddresses: True
    sessionAffinity: None
    type: ClusterIP

   • Use a LoadBalancer service to allow external clients to connect. Keep in mind, that with this option you giving up partition awareness.

     If your environments does not support LoadBalancer, you can use type: NodePort instead. Refer to the Kubernetes documentation for details.

     apiVersion: v1
     kind: Service
     metadata:
      name: gridgain-loadbalancer
      labels:
      app: gridgain
     spec:
      type: LoadBalancer
      selector:
      app: gridgain
      ports:
      - name: rest
      protocol: TCP
      port: 10800
      targetPort: 10800
      - name: client
      port: 10300
      protocol: TCP
      targetPort: 10300

2. Then apply the service.yaml file to set up this service:

1. Prepare the statefulset.yaml file for StatefulSet deployment:

   statefulset.yaml

   apiVersion: apps/v1
   kind: StatefulSet
   metadata:
    # The cluster name.
    name: gridgain-cluster
    # Place your namespace name.
    namespace: <namespace>
   spec:
    # The initial number of pods to be started by Kubernetes.
    replicas: 2
    # Kubernetes service to access the GridGain 9 cluster on the Kubernetes network.
    serviceName: gridgain-svc-headless
    selector:
    matchLabels:
    app: gridgain
    template:
    metadata:
    labels:
    app: gridgain
    spec:
    terminationGracePeriodSeconds: 60000
    containers:
    # Custom pod name.
    - name: gridgain-node
    # Limits and requests for the GridGain container.
    resources:
    limits:
    cpu: "4"
    memory: 4Gi
    requests:
    cpu: "4"
    memory: 4Gi
    env:
    # Must be specified to ensure that GridGain 9 cluster replicas are visible to each other.
    - name: GRIDGAIN_NODE_NAME
    valueFrom:
    fieldRef:
    fieldPath: metadata.name
    # GridGain 9 working directory.
    - name: GRIDGAIN_WORK_DIR
    value: /gg9-work
    # GridGains Docker image and it's version.
    image: gridgain/gridgain9:9.1.16
    ports:
    - containerPort: 10300
    - containerPort: 10800
    - containerPort: 3344
    volumeMounts:
    # The config will be placed at this path in the container.
    - mountPath: /opt/gridgain/etc/gridgain-config.conf
    name: config-vol
    subPath: gridgain-config.conf
    # The license will be placed at this path in the container.
    - mountPath: /opt/gridgain/etc/license.conf
    name: license-vol
    subPath: license.conf
    # GridGain 9 working directory.
    - mountPath: /gg9-work
    name: persistence
    volumes:
    - name: config-vol
    configMap:
    name: gridgain-config
    - name: license-vol
    configMap:
    name: gridgain-license
    volumeClaimTemplates:
    - apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
    name: persistence
    spec:
    accessModes:
    - ReadWriteOnce
    resources:
    requests:
    storage: 10Gi # Provide enough space for your application data.
    volumeMode: Filesystem

2. Apply the statefulset.yaml file to deploy the main components of GridGain 9:

   kubectl apply -f statefulset.yaml

1. Monitor the status of the pods:

   kubectl get pods -n <namespace> -w

2. Ensure that all pods' STATUS is Running before proceeding.

1. Prepare the job.yaml file for deploying the job:

   job.yaml

   apiVersion: batch/v1
   kind: Job
   metadata:
    name: cluster-init
    # Place your namespace name here.
    namespace: <namespace>
   spec:
    template:
    spec:
    containers:
    # Command to init the cluster. URL and host must be the name of the service you created before. Port is 10300 as the management port.
    - args:
    - -ec
    - |
    apt update && apt-get install -y bind9-host
    GG_NODES=$(host -tsrv _cluster._tcp.gridgain-svc-headless | grep 'SRV record' | awk '{print 8ドル}' | awk -F. '{print 1ドル}' | paste -sd ',')
    /opt/gridgain9cli/bin/gridgain9 cluster init --name=gridgain --url=http://gridgain-svc-headless:10300 --license=/opt/gridgain/etc/license.conf
    command:
    - /bin/sh
    # Specify the Docker image with the GridGain 9 CLI and its version.
    image: gridgain/gridgain9:9.1.16
    imagePullPolicy: IfNotPresent
    name: cluster-init
    resources: {}
    volumeMounts:
    # The license required to be mounted to cluster-init job.
    - mountPath: /opt/gridgain/etc/license.conf
    name: license-vol
    subPath: license.conf
    restartPolicy: Never
    terminationGracePeriodSeconds: 120
    volumes:
    - name: license-vol
    configMap:
    name: gridgain-license

2. Apply the job.yaml file to complete installation.

   kubectl apply -f job.yaml