Data Grid Operator Guide

Procedure

1. Extract the .zip archive for the native Data Grid CLI distribution.

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

   cp redhat-datagrid-cli kubectl-infinispan

3. Add kubectl-infinispan to your PATH.

4. Verify that the CLI is installed.

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

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

   oc infinispan --help

Procedure

1. Log in to the OpenShift Web Console.
2. Navigate to OperatorHub.
3. Find and select Data Grid Operator.
4. Select Install and continue to Create Operator Subscription.

5. Specify options for your subscription.

   Installation Mode

   You can install Data Grid Operator into a Specific namespace or All namespaces.

   Update Channel

   Get updates for Data Grid Operator 8.4.x.

   Approval Strategies

   Automatically install updates from the 8.4.x channel or require approval before installation.

6. Select Subscribe to install Data Grid Operator.
7. Navigate to Installed Operators to verify the Data Grid Operator installation.

Procedure

1. Run the oc infinispan install command to create Data Grid Operator subscriptions, for example:

   oc infinispan install --channel=8.4.x
                              --source=redhat-operators
                              --source-namespace=openshift-marketplace

2. Verify the installation.

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

Procedure

1. Set up projects.

   1. Create a project for Data Grid Operator.

   2. If you want Data Grid Operator to control a specific Data Grid cluster only, create a project for that cluster.

      oc new-project ${INSTALL_NAMESPACE} 1
      oc new-project ${WATCH_NAMESPACE} 2

      1

      Creates a project into which you install Data Grid Operator.

      2

      Optionally creates a project for a specific Data Grid cluster if you do not want Data Grid Operator to watch all projects.

2. Create an OperatorGroup resource.

   Control all Data Grid clusters

   oc apply -f - << EOF
   apiVersion: operators.coreos.com/v1
   kind: OperatorGroup
   metadata:
    name: datagrid
    namespace: ${INSTALL_NAMESPACE}
   EOF

   Control a specific Data Grid cluster

   oc apply -f - << EOF
   apiVersion: operators.coreos.com/v1
   kind: OperatorGroup
   metadata:
    name: datagrid
    namespace: ${INSTALL_NAMESPACE}
   spec:
    targetNamespaces:
    - ${WATCH_NAMESPACE}
   EOF

3. Create a subscription for Data Grid Operator.

   oc apply -f - << EOF
   apiVersion: operators.coreos.com/v1alpha1
   kind: Subscription
   metadata:
    name: datagrid-operator
    namespace: ${INSTALL_NAMESPACE}
   spec:
    channel: 8.4.x
    installPlanApproval: Automatic
    name: datagrid
    source: redhat-operators
    sourceNamespace: openshift-marketplace
   EOF

   Note

   If you want to manually approve updates from the 8.4.x channel, change the value of the spec.installPlanApproval field to Manual.

4. Verify the installation.

   oc get pods -n ${INSTALL_NAMESPACE}
   NAME                                   READY   STATUS
   infinispan-operator-<id>               1/1     Running

Procedure

1. Run the infinispan create cluster command.

   For example, create a Data Grid cluster with two pods as follows:

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

   Tip

   Add the --version argument to control the Data Grid version of your cluster. For example, --version=8.4.6-1. If you don’t specify the version, Data Grid Operator creates cluster with the latest supported Data Grid version.

2. Watch Data Grid Operator create the Data Grid pods.

   oc get pods -w

Procedure

1. Create a YAML file that defines your Infinispan CR.

   For example, create a my_infinispan.yaml file that changes the number of Data Grid pods to two:

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

2. Apply your Infinispan CR.

   oc apply -f my_infinispan.yaml

3. Watch Data Grid Operator scale the Data Grid pods.

   oc get pods -w

Procedure

1. Change the spec.replicas field to 0 to stop the Data Grid cluster.

   spec:
     replicas: 0

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

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

3. Change the spec.replicas field to the same number of pods to restart the Data Grid cluster.

   spec:
     replicas: 6

Procedure

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

   XML

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

   YAML

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

   JSON

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

2. Create the ConfigMap from your YAML file.

   oc apply -f cluster-config.yaml

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

   spec:
     configMapName: "cluster-config"

Procedure

1. Create a CredentialStore Secret file.

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

   user-secret.yaml

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

3. Apply your Secret file.

   oc apply -f user-secret.yaml

4. Open the Infinispan CR for editing.

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

   Infinispan CR

   spec:
     security:
       credentialStoreSecretName: user-secret

6. Apply the changes.
7. Open your Data Grid Server configuration for editing.

8. Add a credential-reference to your configuration.

   1. Specify the credentials as the name of the store.

   2. Specify the alias attribute as one of the keys defined in your credential secret.

      Data Grid.xml

      <credential-store>
          <credential-reference store="credentials"  alias="postgres_cred"/>
      </credential-store>

1. Gracefully shuts down the existing cluster.
2. Removes the existing cluster.
3. Creates a new cluster with the target version.

1. Creates a new Data Grid cluster with the target version that runs alongside your existing cluster.
2. Creates a remote cache store to transfer data from the existing cluster to the new cluster.
3. Redirects all clients to the new cluster.
4. Removes the existing cluster when all data and client connections are transferred to the new cluster.

Procedure

1. Specify the Data Grid version number in the spec.version field.

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

   spec:
     version: 8.4.6-1
     upgrades:
       type: Shutdown

3. Apply your changes, if necessary.

Procedure

1. Specify the Data Grid version number in the spec.version field.

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

   spec:
     version: 8.4.6-1
     upgrades:
       type: HotRodRolling

3. Apply your changes.

Procedure

1. 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: <Data Grid_version>
     service:
       type: DataGrid

   Important

   You cannot change the spec.service.type field after you create pods. To change the service type, you must delete the existing pods and create new ones.

2. Apply your Infinispan CR to create the cluster.

Procedure

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

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

   Note

   These fields are mutually exclusive. Add only one of them to your Infinispan CR.

3. Apply the changes.

Procedure

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

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

   The cpu and memory fields have values in the format of <limit>:<requests>. For example, cpu: "2000m:1000m" limits pods to a maximum of 2000m of CPU and requests 1000m of CPU for each pod at startup. Specifying a single value sets both the limit and request.

3. Apply your Infinispan CR.

   If your cluster is running, Data Grid Operator restarts the Data Grid pods so changes take effect.

Procedure

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

2. Apply your Infinispan CR.

   If your cluster is running, Data Grid Operator restarts the Data Grid pods so changes take effect.

Procedure

1. 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

   Important

   If no value is specified for a given probe value, then the Data Grid Operator default is used.

2. Apply your Infinispan CR.

   If your cluster is running, Data Grid Operator restarts the Data Grid pods in order for the changes to take effect.

Procedure

1. Define a PriorityClass object by specifying its name and value.

   high-priority.yaml

   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."

2. Create the priority class.

   oc create -f high-priority.yaml

3. Reference the priority class name in the pod configuration.

   Infinispan CR

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

   You must reference an existing priority class name, otherwise the pod is rejected.

4. Apply the changes.

Procedure

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

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

2. Apply the changes.

3. Retrieve logs from Data Grid pods as required.

   oc logs -f $POD_NAME

Procedure

1. Open your Infinispan CR for editing.

2. Attach labels and annotations to Data Grid resources in the metadata.annotations section.

   • Define values for annotations directly in the metadata.annotations section.
   • Define values for labels with the metadata.labels field.
3. Apply your Infinispan CR.

Procedure

1. Create a subscription definition YAML for your Data Grid Operator:

   1. Use the spec.config.env field to define environment variables.

   2. Within the ADDITIONAL_VARS variable, include environment variable names in a JSON array.

      subscription-datagrid.yaml

      apiVersion: operators.coreos.com/v1alpha1
      kind: Subscription
      metadata:
        name: datagrid
        namespace: openshift-operators
      spec:
        channel: 8.4.x
        installPlanApproval: Automatic
        name: datagrid
        source: redhat-operators
        sourceNamespace: openshift-marketplace
        config:
          env:
          - name: ADDITIONAL_VARS
            value: "[\"VAR_NAME\", \"ANOTHER_VAR\"]"
          - name: VAR_NAME
            value: $(VAR_NAME_VALUE)
          - name: ANOTHER_VAR
            value: $(ANOTHER_VAR_VALUE)

      For example, use the environment variables to set the local time zone:

      subscription-datagrid.yaml

      kind: Subscription
      spec:
        ...
        config:
          env:
          - name: ADDITIONAL_VARS
            value: "[\"TZ\"]"
          - name: TZ
            value: "JST-9"

2. Create a subscription for Data Grid Operator:

   oc apply -f subscription-datagrid.yaml

Next steps

1. Use the oc edit subscription command to modify the environment variable:

   oc edit subscription datagrid -n openshift-operators

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

Procedure

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

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

2. Create an authentication secret from identities.yaml.

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

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

   spec:
     security:
       endpointSecretName: connect-secret

Procedure

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

   spec:
     security:
       endpointAuthentication: false

2. Apply the changes.

Procedure

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

   Note

   The default value is None.

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

   By default Data Grid Operator expects a trust store secret named <cluster-name>-client-cert-secret.

   Note

   The secret must be unique to each Infinispan CR instance in the OpenShift cluster. When you delete the Infinispan CR, OpenShift also automatically deletes the associated secret.

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

3. Apply the changes.

Procedure

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

   Note

   The name must match the value of the spec.security.endpointEncryption.clientCertSecretName field.

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

3. 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>"

4. Apply the changes.

Procedure

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

   Note

   The name must match the value of the spec.security.endpointEncryption.clientCertSecretName field.

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

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

   Note

   Data Grid Operator uses the <name> value as the alias for the certificate when it generates the trust store.

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

   If you do not provide one, Data Grid Operator sets "password" as the trust store password.

   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>"

5. Apply the changes.

Procedure

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

   spec:
     security:
       endpointEncryption:
         type: None

2. Apply the changes.

Procedure

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

   oc apply -f tls_secret.yaml

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

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

3. Apply the changes.

Procedure

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

   spec:
     security:
       authorization:
         enabled: true

2. Apply the changes.

Procedure

1. 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

2. Create an authentication secret from identities.yaml.

   If necessary, delete the existing secret first.

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

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

   spec:
     security:
       endpointSecretName: connect-secret

Procedure

1. Open your Infinispan CR for editing.

2. 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

3. Apply the changes.

Procedure

1. Include spec.expose in your Infinispan CR.
2. Specify LoadBalancer as the service type with the spec.expose.type field.

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

   spec:
     expose:
       type: LoadBalancer
       port: 65535

4. Apply the changes.

5. Verify that the -external service is available.

   oc get services | grep external

Procedure

1. Include spec.expose in your Infinispan CR.
2. Specify NodePort as the service type with the spec.expose.type field.

3. Configure the port where Data Grid is exposed with the spec.expose.nodePort field.

   spec:
     expose:
       type: NodePort
       nodePort: 30000

4. Apply the changes.

5. Verify that the -external service is available.

   oc get services | grep external

Procedure

1. Include spec.expose in your Infinispan CR.
2. Specify Route as the service type with the spec.expose.type field.

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

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

4. Apply the changes.

5. Verify that the route is available.

   oc get routes

Procedure

1. Create an Infinispan CR for each Data Grid cluster.
2. Specify the name of the local site with spec.service.sites.local.name.

3. Configure the expose type for cross-site replication.

   1. Set the value of the spec.service.sites.local.expose.type field to one of the following:

      • NodePort
      • LoadBalancer
      • Route

   2. Optionally specify a port or custom hostname with the following fields:

      • spec.service.sites.local.expose.nodePort if you use a NodePort service.
      • spec.service.sites.local.expose.port if you use a LoadBalancer service.
      • spec.service.sites.local.expose.routeHostName if you use an OpenShift Route.

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

   • LON

     apiVersion: infinispan.org/v1
     kind: Infinispan
     metadata:
       name: infinispan
     spec:
       replicas: 3
       version: <Data Grid_version>
       service:
         type: DataGrid
         sites:
           local:
             name: LON
             expose:
               type: LoadBalancer
               port: 65535
             maxRelayNodes: 1
           locations:
             - name: NYC
               url: infinispan+xsite://infinispan-nyc.myhost.com:7900
       logging:
         categories:
           org.jgroups.protocols.TCP: error
           org.jgroups.protocols.relay.RELAY2: error

   • NYC

     apiVersion: infinispan.org/v1
     kind: Infinispan
     metadata:
       name: infinispan
     spec:
       replicas: 2
       version: <Data Grid_version>
       service:
         type: DataGrid
         sites:
           local:
             name: NYC
             expose:
               type: LoadBalancer
               port: 65535
             maxRelayNodes: 1
           locations:
             - name: LON
               url: infinispan+xsite://infinispan-lon.myhost.com
       logging:
         categories:
           org.jgroups.protocols.TCP: error
           org.jgroups.protocols.relay.RELAY2: error

     Important

     Be sure to adjust logging categories in your Infinispan CR to decrease log levels for JGroups TCP and RELAY2 protocols. This prevents a large number of log files from uses container storage.

     spec:
       logging:
         categories:
           org.jgroups.protocols.TCP: error
           org.jgroups.protocols.relay.RELAY2: error

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

6. Verify that Data Grid clusters form a cross-site view.

   1. Retrieve the Infinispan CR.

      oc get infinispan -o yaml

   2. Check for the type: CrossSiteViewFormed condition.

Procedure

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

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

   The cpu and memory fields have values in the format of <limit>:<requests>. For example, cpu: "2000m:1000m" limits pods to a maximum of 2000m of CPU and requests 1000m of CPU for each pod at startup. Specifying a single value sets both the limit and request.

3. Apply your Infinispan CR.

Procedure

1. Create an Infinispan CR for each Data Grid cluster.
2. Specify the name of the local site with the spec.service.sites.local.name field.
3. For the LON cluster, set false as the value for the spec.service.sites.local.discovery.launchGossipRouter field.
4. For the LON cluster, specify the url with the spec.service.sites.locations.url to connect to the NYC.

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

   LON

   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

   NYC

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

Procedure

1. Create cross-site encryption secrets.

   1. Create keystore secrets.
   2. Create trust store secrets.
2. Modify the Infinispan CR for each Data Grid cluster to specify the secret name for the encryption.transportKeyStore.secretName and encryption.routerKeyStore.secretName fields.

3. Configure any other fields to encrypt RELAY messages as required and then apply the changes.

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

Procedure

1. Create an Infinispan CR for each Data Grid cluster.
2. Specify the name of the local site with spec.service.sites.local.name.
3. Set ClusterIP as the value of the spec.service.sites.local.expose.type field.
4. Provide the name of the Data Grid cluster that acts as a backup location with spec.service.sites.locations.clusterName.

5. If both Data Grid 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

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

7. Verify that Data Grid clusters form a cross-site view.

   1. Retrieve the Infinispan CR.

      oc get infinispan -o yaml

   2. Check for the type: CrossSiteViewFormed condition.

1. In the OpenShift Web Console, select the </> Developer perspective and then select Monitoring.
2. Open the Dashboard tab for the namespace where your Data Grid cluster runs.

3. Open the Metrics tab and confirm that you can query Data Grid metrics such as:

   vendor_cache_manager_default_cluster_size

Procedure

1. Create a ServiceAccount that lets Grafana read Data Grid metrics from Prometheus.

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

   1. Apply the ServiceAccount.

      oc apply -f service-account.yaml

   2. Grant cluster-monitoring-view permissions to the ServiceAccount.

      oc adm policy add-cluster-role-to-user cluster-monitoring-view -z infinispan-monitoring

2. Create a Grafana data source.

   1. Retrieve the token for the ServiceAccount.

      oc serviceaccounts get-token infinispan-monitoring

   2. Define a GrafanaDataSource that includes the token in the spec.datasources.secureJsonData.httpHeaderValue1 field, as in the following example:

      apiVersion: integreatly.org/v1alpha1
      kind: GrafanaDataSource
      metadata:
        name: grafanadatasource
      spec:
        name: datasource.yaml
        datasources:
          - access: proxy
            editable: true
            isDefault: true
            jsonData:
              httpHeaderName1: Authorization
              timeInterval: 5s
              tlsSkipVerify: true
            name: Prometheus
            secureJsonData:
              httpHeaderValue1: >-
                Bearer
                eyJhbGciOiJSUzI1NiIsImtpZCI6Imc4O...
            type: prometheus
            url: 'https://thanos-querier.openshift-monitoring.svc.cluster.local:9091'

3. Apply the GrafanaDataSource.

   oc apply -f grafana-datasource.yaml

Procedure

1. Create a ConfigMap named infinispan-operator-config in the Data Grid 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

2. Specify the namespace of your Data Grid cluster with the data.grafana.dashboard.namespace property.

   Note

   Deleting the value for this property removes the dashboard. Changing the value moves the dashboard to that namespace.

3. Specify a name for the dashboard with the data.grafana.dashboard.name property.
4. If necessary, specify a monitoring key with the data.grafana.dashboard.monitoring.key property.

5. Create infinispan-operator-config or update the configuration.

   oc apply -f infinispan-operator-config.yaml

6. Open the Grafana UI, which is available at:

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

1. Each Data Grid server pod exposes an authenticated JMX endpoint on port 9999 utilizing the "admin" security-realm, which includes the Operator user credentials.
2. The <cluster-name>-admin Service exposes port 9999.

Procedure

1. Enable JMX in your Infinispan CR.

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

2. Retrieve the Operator user credentials to authenticate client JMX connections.

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

Procedure

1. 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

   Note

   The Cryostat Operator requires cert-manager for traffic encryption. If the cert-manager is enabled but not installed, the deployment fails. For details, see the Installing Cryostat guide.

2. Wait for the Cryostat CR to be ready.

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

3. Open the Cryostat status.applicationUrl.

   oc -n <namespace> get cryostat cryostat-sample

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

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

5. In the Cryostat UI, navigate to the Security menu.
6. In the Store Credentials window, click the Add button. The Store Credentials window opens.

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

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

Procedure

1. Add the spec.affinity block to your Infinispan CR.
2. Configure anti-affinity strategies as necessary.
3. Apply your Infinispan CR.

Procedure

1. Create a Cache CR with a unique value in the metadata.name field.
2. Specify the target Data Grid cluster with the spec.clusterName field.

3. Name your cache with the spec.name field.

   Note

   The name attribute in the cache configuration does not take effect. If you do not specify a name with the spec.name field then the cache uses the value of the metadata.name field.

4. Add a cache configuration with the spec.template field.

5. Apply the Cache CR, for example:

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

Procedure

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

   mycache.yaml

   spec:
     updates:
       strategy: recreate

2. Apply changes to the Cache CR, for example:

   oc apply -f mycache.yaml

Procedure

1. Create a Batch CR.

   1. Specify the name of the Data Grid cluster where you want the batch operations to run as the value of the spec.cluster field.

   2. Add each CLI command to run on a line in the spec.config field.

      apiVersion: infinispan.org/v2alpha1
      kind: Batch
      metadata:
        name: mybatch
      spec:
        cluster: infinispan
        config: |
          create cache --template=org.infinispan.DIST_SYNC mycache
          put --cache=mycache hello world
          put --cache=mycache hola mundo

2. Apply your Batch CR.

   oc apply -f mybatch.yaml

3. Wait for the Batch CR to succeed.

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

Procedure

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

   For example, the following batch file creates a cache named "mycache" and adds two entries to it:

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

   Important

   The ConfigMap is mounted in Data Grid pods at /etc/batch. You must prepend all --file= directives in your batch operations with that path.

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

   ls /tmp/mybatch
   
   batch
   mycache.xml

3. Create a ConfigMap from the directory.

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

Procedure

1. Create a Batch CR that specifies the name of a Data Grid cluster as the value of the spec.cluster field.

2. 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

3. Apply your Batch CR.

   oc apply -f mybatch.yaml

4. Wait for the Batch CR to succeed.

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

Procedure

1. Name the Backup CR with the metadata.name field.
2. Specify the Data Grid cluster to backup with the spec.cluster field.

3. 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

4. Optionally include spec.resources fields to specify which Data Grid resources you want to back up.

   If you do not include any spec.resources fields, the Backup CR creates an archive that contains all Data Grid resources. If you do specify spec.resources fields, the Backup CR creates an archive that contains those 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

   You can also use the * wildcard character as in the following example:

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

5. Apply your Backup CR.

   oc apply -f my-backup.yaml

Verification

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

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

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

   oc describe Backup my-backup

Procedure

1. Name the Restore CR with the metadata.name field.
2. Specify a Backup CR to use with the spec.backup field.

3. Specify the Data Grid 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

4. 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

5. Apply your Restore CR.

   oc apply -f my-restore.yaml

Procedure

1. Change to the namespace for your Data Grid cluster.

   oc project rhdg-namespace

2. 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

3. Apply your PVC.

   oc apply -f datagrid-libs.yaml

4. 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: registry.redhat.io/datagrid/datagrid-8-rhel8:8.5
         volumeMounts:
           - mountPath: /tmp/libs
             name: lib-pv-storage

5. Add the pod to the Data Grid namespace and wait for it to be ready.

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

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

   For example to copy code artifacts from a local libs directory, do the following:

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

7. Delete the pod.

   oc delete pod datagrid-libs-pod

   Specify the persistent volume with spec.dependencies.volumeClaimName in your Infinispan CR and then apply the changes.

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

Procedure

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

2. Do one of the following:

   • Specify the location of the file to download via HTTP or FTP as the value of the spec.dependencies.artifacts.url field.
   • Provide the Maven artifact to download with the groupId:artifactId:version format as the value of the spec.dependencies.artifacts.maven field.

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

   The hash field requires a value is in the format of <algorithm>:<checksum> where <algorithm> is sha1|sha224|sha256|sha384|sha512|md5.

   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

4. Apply the changes.

Procedure

1. Run the infinispan shell command to connect to your Data Grid cluster.

   oc infinispan shell <cluster_name>

   Note

   If you have access to authentication secrets and there is only one Data Grid user the kubectl-infinispan plugin automatically detects your credentials and authenticates to Data Grid. If your deployment has multiple Data Grid credentials, specify a user with the --username argument and enter the corresponding password when prompted.

2. Perform CLI operations as required.

   Tip

   Press the tab key or use the --help argument to view available options and help text.

3. Use the quit command to end the remote shell session.