Infinispan Operator 2.5 Guide

Extract the .zip archive for the native Infinispan CLI distribution.

Copy the native executable, or create a hard link, to a file named "kubectl-infinispan", for example:

cp infinispan-cli kubectl-infinispan

Add kubectl-infinispan to your PATH.

Verify that the CLI is installed.

kubectl plugin list

The following compatible plugins are available:
/path/to/kubectl-infinispan

Use the infinispan --help command to view available commands.

kubectl infinispan --help

Log in to the Kubernetes Dashboard.

Navigate to OperatorHub.

Find and select Infinispan Operator.

Select Install and continue to Create Operator Subscription.

Specify options for your subscription.

Select Subscribe to install Infinispan Operator.

Navigate to Installed Operators to verify the Infinispan Operator installation.

Run the oc infinispan install command to create Infinispan Operator subscriptions, for example:

kubectl infinispan install --channel=stable
                           --source=redhat-operators
                           --source-namespace=openshift-marketplace

Verify the installation.

kubectl get pods -n openshift-operators | grep infinispan-operator
NAME                                   READY   STATUS
infinispan-operator-<id>               1/1     Running

Navigate to the Infinispan Operator entry on OperatorHub.io.

Follow the instructions to install Infinispan Operator into your Kubernetes cluster.

Run the infinispan create cluster command.

kubectl infinispan create cluster --replicas=3 -Pservice.type=DataGrid infinispan

Watch Infinispan Operator create the Infinispan pods.

kubectl get pods -w

Create a YAML file that defines your Infinispan CR.

cat > cr_minimal.yaml<<EOF
apiVersion: infinispan.org/v1
kind: Infinispan
metadata:
  name: infinispan
spec:
  replicas: 2
  version: <Infinispan_version>
  service:
    type: DataGrid
EOF

Apply your Infinispan CR.

kubectl apply -f my_infinispan.yaml

Watch Infinispan Operator scale the Infinispan pods.

kubectl get pods -w

Change the spec.replicas field to 0 to stop the Infinispan cluster.

spec:
  replicas: 0

Ensure you have the correct number of pods before you restart the cluster.

kubectl get infinispan infinispan -o=jsonpath='{.status.replicasWantedAtRestart}'

Change the spec.replicas field to the same number of pods to restart the Infinispan cluster.

spec:
  replicas: 6

Add Infinispan configuration to a infinispan-config.[xml|yaml|json] key in the data field of your ConfigMap.

apiVersion: v1
kind: ConfigMap
metadata:
   name: cluster-config
   namespace: ispn-namespace
data:
   infinispan-config.xml: >
     <infinispan>
       <!-- Custom configuration goes here. -->
     </infinispan>

apiVersion: v1
kind: ConfigMap
metadata:
   name: cluster-config
   namespace: ispn-namespace
data:
   infinispan-config.yaml: >
     infinispan:
       # Custom configuration goes here.

apiVersion: v1
kind: ConfigMap
metadata:
   name: cluster-config
   namespace: ispn-namespace
data:
   infinispan-config.json: >
     {
       "infinispan": {
       }
     }

Create the ConfigMap from your YAML file.

kubectl apply -f cluster-config.yaml

Specify the name of the ConfigMap with the spec.configMapName field in your Infinispan CR and then apply the changes.

spec:
  configMapName: "cluster-config"

Create a CredentialStore Secret file.

Use the data field to specify the credentials and its aliases.

apiVersion: v1
kind: Secret
metadata:
  name: user-secret
type: Opaque
data:
  postgres_cred: sensitive-value
  mysql_cred: sensitive-value2

Apply your Secret file.

kubectl apply -f user-secret.yaml

Open the Infinispan CR for editing.

In the spec.security.credentialStoreSecretName field, specify the name of the credential store secret.

spec:
  security:
    credentialStoreSecretName: user-secret

Apply the changes.

Open your Infinispan Server configuration for editing.

Add a credential-reference to your configuration.

Gracefully shuts down the existing cluster.

Removes the existing cluster.

Creates a new cluster with the target version.

Checks if the Infinispan version supports rolling upgrades.

Checks whether the current version and target version have matching major and minor versions.

If the conditions above are met, the Operator will upgrade server pods one by one using a StatefulSet RollingUpdate.

Creates a new Infinispan cluster with the target version that runs alongside your existing cluster.

Creates a remote cache store to transfer data from the existing cluster to the new cluster.

Redirects all clients to the new cluster.

Removes the existing cluster when all data and client connections are transferred to the new cluster.

Specify the Infinispan version number in the spec.version field.

Ensure that Shutdown is set as the value for the spec.upgrades.type field, which is the default.

spec:
  version: 16.0.0
  upgrades:
    type: Shutdown

Apply your changes, if necessary.

Specify the Infinispan version number in the spec.version field.

Ensure that InPlaceRolling is set as the value for the spec.upgrades.type field.

spec:
  version: 16.0.0
  upgrades:
    type: InPlaceRolling

Apply your changes, if necessary.

Specify the Infinispan version number in the spec.version field.

Specify HotRodRolling as the value for the spec.upgrades.type field.

spec:
  version: 16.0.0
  upgrades:
    type: HotRodRolling

Apply your changes.

Create an Infinispan CR that sets spec.service.type: DataGrid and configures any other Data Grid Service resources.

apiVersion: infinispan.org/v1
kind: Infinispan
metadata:
  name: infinispan
spec:
  replicas: 2
  version: <Infinispan_version>
  service:
    type: DataGrid

Apply your Infinispan CR to create the cluster.

Allocate storage resources with the spec.service.container.storage field.

Configure either the ephemeralStorage field or the storageClassName field as required.

Apply the changes.

Allocate the number of CPU units with the spec.container.cpu field.

Allocate the amount of memory, in bytes, with the spec.container.memory field.

Apply your Infinispan CR.

Configure JVM options with the spec.container filed in your Infinispan CR.

Apply your Infinispan CR.

Configure probe values using the spec.service.container.*Probe fields:

spec:
  service:
    container:
      readinessProbe:
        failureThreshold: 1
        initialDelaySeconds: 1
        periodSeconds: 1
        successThreshold: 1
        timeoutSeconds: 1
      livenessProbe:
        failureThreshold: 1
        initialDelaySeconds: 1
        periodSeconds: 1
        successThreshold: 1
        timeoutSeconds: 1
      startupProbe:
        failureThreshold: 1
        initialDelaySeconds: 1
        periodSeconds: 1
        successThreshold: 1
        timeoutSeconds: 1

Apply your Infinispan CR.

Define a PriorityClass object by specifying its name and value.

apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
  name: high-priority
value: 1000000
globalDefault: false
description: "Use this priority class for high priority service pods only."

Create the priority class.

kubectl create -f high-priority.yaml

Reference the priority class name in the pod configuration.

kind: Infinispan
...
spec:
  scheduling:
    affinity:
      ...
    priorityClassName: "high-priority"
    ...

Apply the changes.

Configure probe values using the spec.service.container.terminationGracePeriodSeconds field:

spec:
  service:
    container:
      terminationGracePeriodSeconds: 60

Apply your Infinispan CR.

Configure Infinispan logging with the spec.logging.pattern field in your Infinispan CR.

spec:
  logging:
    pattern: %X{address} %X{user} [%d{dd/MMM/yyyy:HH:mm:ss Z}]

Apply the changes.

Retrieve logs from Infinispan pods as required.

kubectl logs -f $POD_NAME

Configure Infinispan logging with the spec.logging.categories field in your Infinispan CR.

spec:
  logging:
    categories:
      org.infinispan: debug
      org.jgroups: debug

Apply the changes.

Retrieve logs from Infinispan pods as required.

kubectl logs -f $POD_NAME

Open your Infinispan CR for editing.

Attach labels and annotations to Infinispan resources in the metadata.annotations section.

Apply your Infinispan CR.

Create a subscription definition YAML for your Infinispan Operator:

Create a subscription for Infinispan Operator:

kubectl apply -f subscription-infinispan.yaml

Use the kubectl edit subscription command to modify the environment variable:

kubectl edit subscription infinispan -n operators

To ensure the changes take effect on your Infinispan clusters, you must recreate the existing clusters. Terminate the pods by deleting the StatefulSet associated with the existing Infinispan CRs.

Create an identities.yaml file with the credentials that you want to add.

credentials:
- username: myfirstusername
  password: changeme-one
- username: mysecondusername
  password: changeme-two

Create an authentication secret from identities.yaml.

kubectl create secret generic --from-file=identities.yaml connect-secret

Specify the authentication secret with spec.security.endpointSecretName in your Infinispan CR and then apply the changes.

spec:
  security:
    endpointSecretName: connect-secret

Set false as the value for the spec.security.endpointAuthentication field in your Infinispan CR.

spec:
  security:
    endpointAuthentication: false

Apply the changes.

Set either Validate or Authenticate as the value for the spec.security.endpointEncryption.clientCert field in your Infinispan CR.

Specify the secret that contains the client trust store with the spec.security.endpointEncryption.clientCertSecretName field.

spec:
  security:
    endpointEncryption:
        type: Secret
        certSecretName: tls-secret
        clientCert: Validate
        clientCertSecretName: infinispan-client-cert-secret

Apply the changes.

Specify the name of the secret that contains the client trust store as the value of the metadata.name field.

Provide the password for the trust store with the stringData.truststore-password field.

Specify the trust store with the data.truststore.p12 field.

apiVersion: v1
kind: Secret
metadata:
  name: infinispan-client-cert-secret
type: Opaque
stringData:
    truststore-password: changme
data:
    truststore.p12:  "<base64_encoded_PKCS12_trust_store>"

Apply the changes.

Specify the name of the secret that contains the client trust store as the value of the metadata.name field.

Specify the signing certificate, or CA certificate bundle, as the value of the data.trust.ca field.

If you use the Authenticate strategy to verify client identities, add the certificate for each client that can connect to Infinispan endpoints with the data.trust.cert.<name> field.

Optionally provide a password for the trust store with the stringData.truststore-password field.

apiVersion: v1
kind: Secret
metadata:
  name: infinispan-client-cert-secret
type: Opaque
stringData:
    truststore-password: changme
data:
    trust.ca: "<base64_encoded_CA_certificate>"
    trust.cert.client1: "<base64_encoded_client_certificate>"
    trust.cert.client2: "<base64_encoded_client_certificate>"

Apply the changes.

Set None as the value for the spec.security.endpointEncryption.type field in your Infinispan CR.

spec:
  security:
    endpointEncryption:
      type: None

Apply the changes.

Add the encryption secret to your OpenShift namespace, for example:

kubectl apply -f tls_secret.yaml

Specify the encryption secret with the spec.security.endpointEncryption.certSecretName field in your Infinispan CR.

spec:
  security:
    endpointEncryption:
      type: Secret
      certSecretName: tls-secret

Apply the changes.

Set true as the value for the spec.security.authorization.enabled field in your Infinispan CR.

spec:
  security:
    authorization:
      enabled: true

Apply the changes.

Create an identities.yaml file that assigns roles to users.

credentials:
  - username: admin
    password: changeme
  - username: my-user-1
    password: changeme
    roles:
      - admin
  - username: my-user-2
    password: changeme
    roles:
      - monitor

Create an authentication secret from identities.yaml.

kubectl delete secret connect-secret --ignore-not-found
kubectl create secret generic --from-file=identities.yaml connect-secret

Specify the authentication secret with spec.security.endpointSecretName in your Infinispan CR and then apply the changes.

spec:
  security:
    endpointSecretName: connect-secret

Open your Infinispan CR for editing.

Specify custom roles and their associated permissions with the spec.security.authorization.roles field.

spec:
  security:
    authorization:
      enabled: true
      roles:
        - name: my-role-1
          permissions:
            - ALL
        - name: my-role-2
          permissions:
            - READ
            - WRITE

Apply the changes.

Include spec.expose in your Infinispan CR.

Specify LoadBalancer as the service type with the spec.expose.type field.

Optionally specify the network port where the service is exposed with the spec.expose.port field.

spec:
  expose:
    type: LoadBalancer
    port: 65535

Apply the changes.

Verify that the -external service is available.

kubectl get services | grep external

Include spec.expose in your Infinispan CR.

Specify NodePort as the service type with the spec.expose.type field.

Configure the port where Infinispan is exposed with the spec.expose.nodePort field.

spec:
  expose:
    type: NodePort
    nodePort: 30000

Apply the changes.

Verify that the -external service is available.

kubectl get services | grep external

Include spec.expose in your Infinispan CR.

Specify Route as the service type with the spec.expose.type field.

Optionally add a hostname with the spec.expose.host field.

spec:
  expose:
    type: Route
    host: www.example.org

Apply the changes.

Verify that the route is available.

kubectl get ingress

Create an Infinispan CR for each Infinispan cluster.

Specify the name of the local site with spec.service.sites.local.name.

Configure the expose type for cross-site replication.

Provide the name and static URL for each Infinispan cluster that acts as a backup location with spec.service.sites.locations, for example:

Configure your Infinispan CRs with any other Data Grid Service resources and then apply the changes.

Verify that Infinispan clusters form a cross-site view.

Allocate the number of CPU units using the service.sites.local.discovery.cpu field.

Allocate the amount of memory, in bytes, using the service.sites.local.discovery.memory field.

Apply your Infinispan CR.

Create an Infinispan CR for each Infinispan cluster.

Specify the name of the local site with the spec.service.sites.local.name field.

For the LON cluster, set false as the value for the spec.service.sites.local.discovery.launchGossipRouter field.

For the LON cluster, specify the url with the spec.service.sites.locations.url to connect to the NYC.

In the NYC configuration, do not specify the spec.service.sites.locations.url.

apiVersion: infinispan.org/v1
kind: Infinispan
metadata:
  name: infinispan
spec:
  replicas: 3
  service:
    type: DataGrid
    sites:
      local:
        name: LON
        discovery:
          launchGossipRouter: false
      locations:
        - name: NYC
          url: infinispan+xsite://infinispan-nyc.myhost.com:7900

apiVersion: infinispan.org/v1
kind: Infinispan
metadata:
  name: infinispan
spec:
  replicas: 3
  service:
    type: DataGrid
    sites:
      local:
        name: NYC
      locations:
        - name: LON

Create the key store and trust store using Keytool (certificate management utility included with Java).

Create cross-site encryption secret for each Infinispan cluster.

Modify the Infinispan CR for each Infinispan cluster to specify the secret name for the encryption.transportKeyStore.secretName and encryption.routerKeyStore.secretName fields.

apiVersion: infinispan.org/v1
kind: Infinispan
metadata:
  name: infinispan
spec:
  replicas: 2
  version: <Infinispan_version>
  expose:
    type: LoadBalancer
  service:
    type: DataGrid
    sites:
      local:
        name: SiteA
        # ...
        encryption:
          protocol: TLSv1.3
          transportKeyStore:
            secretName: keystore-tls-secret
            alias: server
            filename: keystore.p12
          routerKeyStore:
            secretName: keystore-tls-secret
            alias: server
            filename: keystore.p12
          trustStore:
            secretName: truststore-tls-secret
            filename: truststore.p12
      locations:
        # ...

Create an Infinispan CR for each Infinispan cluster.

Specify the name of the local site with spec.service.sites.local.name.

Set ClusterIP as the value of the spec.service.sites.local.expose.type field.

Provide the name of the Infinispan cluster that acts as a backup location with spec.service.sites.locations.clusterName.

If both Infinispan clusters have the same name, specify the namespace of the backup location with spec.service.sites.locations.namespace.

apiVersion: infinispan.org/v1
kind: Infinispan
metadata:
  name: example-clustera
spec:
  replicas: 1
  expose:
    type: LoadBalancer
  service:
    type: DataGrid
    sites:
      local:
        name: SiteA
        expose:
          type: ClusterIP
        maxRelayNodes: 1
      locations:
        - name: SiteB
          clusterName: example-clusterb
          namespace: cluster-namespace

Configure your Infinispan CRs with any other Data Grid Service resources and then apply the changes.

Verify that Infinispan clusters form a cross-site view.

In the Kubernetes Dashboard, select the </> Developer perspective and then select Monitoring.

Open the Dashboard tab for the namespace where your Infinispan cluster runs.

Open the Metrics tab and confirm that you can query Infinispan metrics such as:

vendor_cache_manager_default_cluster_size

Create a ServiceAccount that lets Grafana read Infinispan metrics from Prometheus.

apiVersion: v1
kind: ServiceAccount
metadata:
  name: infinispan-monitoring

Create a Grafana data source.

Apply the GrafanaDataSource.

oc apply -f grafana-datasource.yaml

Create a ConfigMap named infinispan-operator-config in the Infinispan Operator namespace.

apiVersion: v1
kind: ConfigMap
metadata:
  name: infinispan-operator-config
data:
  grafana.dashboard.namespace: infinispan
  grafana.dashboard.name: infinispan
  grafana.dashboard.monitoring.key: middleware

Specify the namespace of your Infinispan cluster with the data.grafana.dashboard.namespace property.

Specify a name for the dashboard with the data.grafana.dashboard.name property.

If necessary, specify a monitoring key with the data.grafana.dashboard.monitoring.key property.

Create infinispan-operator-config or update the configuration.

oc apply -f infinispan-operator-config.yaml

Open the Grafana UI, which is available at:

oc get routes grafana-route -o jsonpath=https://"{.spec.host}"

Each Infinispan server pod exposes an authenticated JMX endpoint on port 9999 utilizing the "admin" security-realm, which includes the Operator user credentials.

The <cluster-name>-admin Service exposes port 9999.

Enable JMX in your Infinispan CR.

apiVersion: infinispan.org/v1
kind: Infinispan
metadata:
  name: infinispan
spec:
  jmx:
    enabled: true

Retrieve the Operator user credentials to authenticate client JMX connections.

kubectl get secret infinispan-generated-operator-secret -o jsonpath="{.data.identities\.yaml}" | base64 --decode

Create a Cryostat CR in the same namespace as your Infinispan CR.

apiVersion: operator.cryostat.io/v1beta1
kind: Cryostat
metadata:
  name: cryostat-sample
spec:
  minimal: false
  enableCertManager: true

Wait for the Cryostat CR to be ready.

kubectl wait -n <namespace> --for=condition=MainDeploymentAvailable cryostat/cryostat-sample

Open the Cryostat status.applicationUrl.

kubectl -n <namespace> get cryostat cryostat-sample

Retrieve the Operator user credentials to authenticate client JMX connections in the Cryostat UI.

kubectl get secret infinispan-generated-operator-secret -o jsonpath="{.data.identities\.yaml}" | base64 --decode

In the Cryostat UI, navigate to the Security menu.

In the Store Credentials window, click the Add button. The Store Credentials window opens.

In the Match Expression filed, enter match expression details in the following format:

target.labels['infinispan_cr'] == '<cluster_name>'

Add the spec.scheduling.affinity block to your Infinispan CR.

Configure anti-affinity strategies as necessary.

Apply your Infinispan CR.

Define a HorizontalPodAutoscaler resource in the same namespace as your Infinispan CR

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: infinispan-auto
spec:
  scaleTargetRef:
    apiVersion: infinispan.org/v1
    kind: Infinispan
    name: example (1)
  minReplicas: 1
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 50

Create a Cache CR with a unique value in the metadata.name field.

Specify the target Infinispan cluster with the spec.clusterName field.

Name your cache with the spec.name field.

Add a cache configuration with the spec.template field.

Apply the Cache CR, for example:

kubectl apply -f mycache.yaml
cache.infinispan.org/mycachedefinition created

Use the spec.updates.strategy field to set the Cache CR strategy.

spec:
  updates:
    strategy: recreate

Apply changes to the Cache CR, for example:

oc apply -f mycache.yaml

Create a Batch CR.

Apply your Batch CR.

kubectl apply -f mybatch.yaml

Wait for the Batch CR to succeed.

kubectl wait --for=jsonpath='{.status.phase}'=Succeeded Batch/mybatch

Create a batch file that contains all commands you want to run.

create cache mycache --file=/etc/batch/mycache.xml
put --cache=mycache hello world
put --cache=mycache hola mundo

Ensure all configuration artifacts that your batch operations require are in the same directory as the batch file.

ls /tmp/mybatch

batch
mycache.xml

Create a ConfigMap from the directory.

kubectl create configmap mybatch-config-map --from-file=/tmp/mybatch

Create a Batch CR that specifies the name of a Infinispan cluster as the value of the spec.cluster field.

Set the name of the ConfigMap that contains your batch file and configuration artifacts with the spec.configMap field.

cat > mybatch.yaml<<EOF
apiVersion: infinispan.org/v2alpha1
kind: Batch
metadata:
  name: mybatch
spec:
  cluster: infinispan
  configMap: mybatch-config-map
EOF

Apply your Batch CR.

kubectl apply -f mybatch.yaml

Wait for the Batch CR to succeed.

kubectl wait --for=jsonpath='{.status.phase}'=Succeeded Batch/mybatch

Name the Backup CR with the metadata.name field.

Specify the Infinispan cluster to backup with the spec.cluster field.

Configure the persistent volume claim (PVC) that adds the backup archive to the persistent volume (PV) with the spec.volume.storage and spec.volume.storage.storageClassName fields.

apiVersion: infinispan.org/v2alpha1
kind: Backup
metadata:
  name: my-backup
spec:
  cluster: source-cluster
  volume:
    storage: 1Gi
    storageClassName: my-storage-class

Optionally include spec.resources fields to specify which Infinispan resources you want to back up.

spec:
  ...
  resources:
    templates:
      - distributed-sync-prod
      - distributed-sync-dev
    caches:
      - cache-one
      - cache-two
    counters:
      - counter-name
    protoSchemas:
      - authors.proto
      - books.proto
    tasks:
      - wordStream.js

spec:
  ...
  resources:
    caches:
      - "*"
    protoSchemas:
      - "*"

Apply your Backup CR.

kubectl apply -f my-backup.yaml

Check that the status.phase field has a status of Succeeded in the Backup CR and that Infinispan logs have the following message:

ISPN005044: Backup file created 'my-backup.zip'

Run the following command to check that the backup is successfully created:

kubectl describe Backup my-backup -n namespace

Name the Restore CR with the metadata.name field.

Specify a Backup CR to use with the spec.backup field.

Specify the Infinispan cluster to restore with the spec.cluster field.

apiVersion: infinispan.org/v2alpha1
kind: Restore
metadata:
  name: my-restore
spec:
  backup: my-backup
  cluster: target-cluster

Optionally add the spec.resources field to restore specific resources only.

spec:
  ...
  resources:
    templates:
      - distributed-sync-prod
      - distributed-sync-dev
    caches:
      - cache-one
      - cache-two
    counters:
      - counter-name
    protoSchemas:
      - authors.proto
      - books.proto
    tasks:
      - wordStream.js

Apply your Restore CR.

kubectl apply -f my-restore.yaml

Change to the namespace for your Infinispan cluster.

kubectl config set-context --current --namespace=ispn-namespace

Create a PVC for your custom code artifacts, for example:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: datagrid-libs
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 100Mi

Apply your PVC.

kubectl apply -f datagrid-libs.yaml

Create a pod that mounts the PVC, for example:

apiVersion: v1
kind: Pod
metadata:
  name: datagrid-libs-pod
spec:
  securityContext:
    fsGroup: 2000
  volumes:
    - name: lib-pv-storage
      persistentVolumeClaim:
        claimName: datagrid-libs
  containers:
    - name: lib-pv-container
      image: quay.io/infinispan/server:16.0.0
      volumeMounts:
        - mountPath: /tmp/libs
          name: lib-pv-storage

Add the pod to the Infinispan namespace and wait for it to be ready.

kubectl apply -f datagrid-libs-pod.yaml
kubectl wait --for=condition=ready --timeout=2m pod/datagrid-libs-pod

Copy your code artifacts to the pod so that they are loaded into the PVC.

kubectl cp --no-preserve=true libs datagrid-libs-pod:/tmp/

Delete the pod.

kubectl delete pod datagrid-libs-pod

apiVersion: infinispan.org/v1
kind: Infinispan
metadata:
  name: infinispan
spec:
  replicas: 2
  dependencies:
    volumeClaimName: datagrid-libs
  service:
    type: DataGrid

Add the spec.dependencies.artifacts field to your Infinispan CR.

Do one of the following:

Optionally specify a checksum to verify the integrity of the download with the spec.dependencies.artifacts.hash field.

apiVersion: infinispan.org/v1
kind: Infinispan
metadata:
  name: infinispan
spec:
  replicas: 2
  dependencies:
    artifacts:
      - url: http://example.com:8080/path
        hash: sha256:596408848b56b5a23096baa110cd8b633c9a9aef2edd6b38943ade5b4edcd686
  service:
    type: DataGrid

Apply the changes.

Run the infinispan shell command to connect to your Infinispan cluster.

kubectl infinispan shell <cluster_name>

Perform CLI operations as required.

Use the quit command to end the remote shell session.