Upgrade Instructions

Follow these step-by-step instructions to upgrade Kloudfuse using Helm, including the upgrade command and version-specific notes for all supported releases.

Upgrade with kfuse-upgrade.sh (recommended)

Prefer the kfuse-upgrade.sh orchestrator over the plain Helm command in Helm upgrade command. It runs the same helm upgrade and additionally:

  • Restarts stateful components in dependency order — ZooKeeper, then Kafka, then the Pinot controller, then (after the Kloudfuse setup jobs complete) Pinot brokers, servers, and minions — so schema and table-config changes are applied before the Pinot servers restart. This removes the manual rollout restart that some upgrades previously required.

  • Restarts only components whose configuration actually changed; unchanged components are left untouched.

  • Waits for the Kloudfuse setup jobs, health-checks each component between restarts, and verifies the whole deployment converged before reporting success.

Download the script

Download the script from the public Kloudfuse customer repository:

curl -fsSLO https://raw.githubusercontent.com/kloudfuse-ext/customer/main/scripts/kfuse-upgrade.sh
chmod +x kfuse-upgrade.sh

The script requires kubectl, helm 3.13 or later, and jq, and uses your current kubeconfig context. Verify the context points at the intended cluster before running it.

Run the upgrade

./kfuse-upgrade.sh upgrade custom-values.yaml <VERSION> --token token.json (1) (2)
1 Replace <VERSION> with a valid Kloudfuse release value. See Release Notes for the latest release.
2 --token token.json is the registry key from your Kloudfuse license. Omit it if this machine has already run helm registry login (for example, during installation).

If your installation uses a namespace or release name other than kfuse, add -n <namespace> and -r <release>.

The script prints a restart plan and asks for confirmation before restarting any pods. Pass --yes for unattended runs.

Faster restarts on large clusters

By default, pods restart one at a time (rolling), which keeps every component serving throughout the upgrade. On clusters with many Pinot pods, rolling through them can take a long time. Use recreate mode for Pinot so that each tier’s pods are deleted and recreated in parallel:

./kfuse-upgrade.sh upgrade custom-values.yaml <VERSION> --token token.json --recreate 'pinot-*'

Recreate mode takes each Pinot tier fully down for roughly one pod-startup time (instead of N startups one after the other with rolling). Queries are briefly unavailable while brokers and servers restart, and real-time ingestion catches up from Kafka afterward. The dependency ordering between tiers is preserved, and ZooKeeper always restarts one pod at a time regardless of this flag.

Check the deployment afterward

./kfuse-upgrade.sh status

Reports every managed component’s readiness and whether any pods are still on an old version; exits non-zero if anything has not converged. Additional subcommands: restart <component> (orchestrated restart of one component, for example restart 'pinot-server-*'), and rollback (helm rollback followed by the same ordered restarts). Run ./kfuse-upgrade.sh --help for the complete reference.

Helm upgrade command

If you cannot use the orchestrator, the plain Helm upgrade below is still supported. Note that some upgrades (for example, those changing Pinot schemas) may additionally require manually restarting Pinot components afterward — the orchestrator in Upgrade with kfuse-upgrade.sh (recommended) handles that ordering automatically.

  1. Before performing an upgrade, validate that the upgrade won’t revert any customization on your cluster.

  2. To check which Kloudfuse version you have, run the following command:

    helm list
  3. Run the upgrade command.

    helm upgrade --install kfuse oci://us-east1-docker.pkg.dev/mvp-demo-301906/kfuse-helm/kfuse \
      -n kfuse \
      --version <VERSION> \ (1)
      -f custom-values.yaml
    bash
    1 Replace <VERSION> with a valid Kloudfuse release value. See Release Notes for the latest release.

Version Specific Instructions

Upgrade to 4.4.0

Pre-Upgrade Steps

Upgrade From 4.3.0 or 4.2.4

You can upgrade to Release 4.4.0 from Release 4.3.0 or Release 4.2.4. From an earlier release, upgrade to Release 4.2.4 first.

From Release 4.2.4, also complete the 4.3.0 pre-upgrade and post-upgrade steps, except Enable Performance Logs.

Review Log Normalization Changes

Log normalization (remap) turns each agent’s raw payload into a log’s message, timestamp, source, and labels. Release 4.3.0 changed how logs from several agents are normalized. Release 4.4.0 reverts those changes, so logs are normalized as in Release 4.2.4 again, apart from a few deliberate differences. What you need to check depends on the release you are upgrading from.

Remap rules can be in two places; check both:

  • Your custom-values.yaml file — each - remap: item under logs-parser.kf_parsing_config.config. See Remap.

  • The Logs Remap page in the new Kloudfuse UI, if global.logs.remap.configDb.enabled is true. See Remap Concepts.

If you are upgrading from Release 4.3.0, undo any changes you made to work around its normalization. Search dashboards, alerts, saved queries, and parsing rules for:

  • Agent otlp-json or otlp-proto — OpenTelemetry logs have the agent otlp again. Change a filter such as agent="otlp-json" to agent="otlp".

  • Source unknown — OpenTelemetry logs get their real source again.

  • OpenTelemetry labels — cloud_account_id, kube_service, service_name, and level (lowercase) are back to their 4.2.4 names and values.

  • Remap rules you split or reordered for 4.3.0 — as in 4.2.4, remap rules without conditions apply to every agent, every matching rule applies, and archive rules that match the log message work.

Whether you are upgrading from Release 4.3.0 or Release 4.2.4, these differences from Release 4.2.4 remain. Check your remap rules and queries for:

  • Remap rules with conditions on fields other than __kf_agent — remap evaluates only __kf_agent conditions. If a rule’s __kf_agent condition uses ==, the rule’s other conditions are ignored, and the rule applies to every log from that agent. In the following rule, the #namespace condition is ignored, so the rule changes every Fluent Bit log, not only logs from prod:

    - remap:
        args:
          kf_source:
            - "$.app"
        conditions:
          - matcher: "__kf_agent"
            value: "fluent-bit"
            op: "=="
          - matcher: "#namespace"   # ignored
            value: "prod"
            op: "=="
    yaml

    If the __kf_agent condition uses any other operator, such as != or =~, the whole rule is skipped. In 4.2.4, neither kind of rule applied. To keep a condition on another field, remove it from the remap rule and move that logic to a relabel step, which evaluates every condition.

  • Remap rules without conditions that set kf_source, kf_msg, or other kf_ fields* — the path in such a rule overrides the field that each agent sets itself. For example, a rule with no conditions that sets kf_source to $.app replaces the source of every log that has an app field.

  • kf_timestamp_from_agent_format — it is ignored. On the Logs Remap page, enter the format under Custom timestamp formats as a Go time layout; for example, yyyy-MM-dd’T’HH:mm:ss.SSSZ becomes 2006-01-02T15:04:05.000Z0700. Custom formats cannot be set in custom-values.yaml.

  • Level filters — levels that start with info or warn are now info or warn. Change a filter such as level="warnings" to level="warn".

  • A host key in OpenTelemetry log messages — OpenTelemetry logs now get host and instance_id labels, so the message’s host key becomes the facet host_1. Update queries that use the host facet.

Review Metric Shaping and Relabel Rules
  • Shaping rules on the same metric must agree on whether to keep the original metric. If any of them drops it, it is now dropped. To fix a conflict, pause one rule, edit it, and resume it. See Metric Shaping Rules.

  • Paused shaping rules no longer drop the original metric. To keep dropping it, resume the rule.

  • Relabel rules now see ingestion API key labels. Retention, drop, keep, and replace rules that match these labels now apply to them. See Ingestion Authentication with API Key.

Archive Bucket Permissions

If archiving is enabled, the archive writer does not start unless it can write, overwrite, and read objects in the archive bucket. Grant these permissions:

  • Amazon S3 — s3:GetObject and s3:ListBucket, in addition to s3:PutObject.

  • Google Cloud Storage — storage.objects.create, .get, .list, and .delete, for example through Storage Object Admin. Storage Object Creator with Viewer is not enough.

  • Azure Blob Storage — set global.archive.useSecret to true; the upgrade fails if it is false.

See Storage access. Do not apply a Google Cloud Storage retention policy or Azure immutability to the bucket. If the archive writer does not start, look for cloud bucket probe failed in its log.

Increase Real-Time Storage Server Heap

New metric data is stored more compactly (see Smaller Metric Storage), and each rollup resolution is held separately while it is ingested, so real-time storage servers need more heap and more memory-mapped off-heap memory. In Kloudfuse testing, heap grew by about 2.5 times the current off-heap memory used by the kf_metrics table, and mapped off-heap memory grew by about the same amount. Check the 7-day peak of that off-heap memory; the current value drops each time a segment seals:

max(max_over_time(pinot_server_realtime_offheapMemoryUsed_Value{table="kf_metrics"}[7d]))
Contact Kloudfuse support for exact numbers for your cluster, including real-time storage server memory, Kafka broker disk size, and retentionBytes.

Before you upgrade, increase jvmMemory (4G if unset) by about 2.5 times that value. Small clusters need at least 3 times their current heap; for example, 4G becomes 12G:

pinot:
  server:
    realtime:
      jvmMemory: <current + 2.5 × kf_metrics off-heap memory>   # at least 3x on small clusters
yaml

If you set jvmOpts for these servers, change -Xms and -Xmx there instead. The node must have room for the larger heap and for the extra mapped off-heap memory, because both come out of the node’s memory. After the upgrade, if jvm_memory_used_bytes{area="heap"} nears jvm_memory_max_bytes, or servers restart with java.lang.OutOfMemoryError, increase jvmMemory further.

Update Rollup Settings and Kafka Topics

Metrics now roll up at two fixed resolutions, 5 and 30 minutes, written to kf_metrics_rollup_300_topic and kf_metrics_rollup_1800_topic.

Remove these settings if you set them. The Helm upgrade fails while any of them is set:

  • global.metrics.rollupIntervalSecs

  • global.metrics.rollupResolutionFactors

  • query-service.config.Metric.RollupIntervalSecs

  • query-service.config.Metric.RollupResolutionFactors

  • query-service.advancefunctions.config.Metric.RollupIntervalSecs

  • query-service.advancefunctions.config.Metric.RollupResolutionFactors

  • metrics-transformer.config.MetricRollupGen.RollupIntervalSecs

  • metrics-transformer.config.MetricRollupGen.RollupResolutionFactors

  • metrics-transformer.config.MetricRollupGen.RollupResolutions

  • metrics-transformer.config.MetricRollupTimeSeriesProducer.Topic

Also remove these. They no longer have any effect:

  • query-service.config.Metric.RollupMinRangeSecs

  • query-service.rulemanager.config.Metric.RollupMinRangeSecs

  • metrics-transformer.config.KafkaProducer.Topic

If you set rollupIntervalSecs to anything other than 300, or RollupMinRangeSecs to anything other than 600, contact Kloudfuse support first.

Update global.kafkaTopics in your custom-values.yaml file:

  • Add the rollup topics to your existing list, keeping kf_metrics_rollup_topic. If a topic is missing, the upgrade fails and suggests entries based on kf_metrics_topic; use the kf_metrics_rollup_topic values instead.

    global:
      kafkaTopics:
        # ... your existing topics, including kf_metrics_rollup_topic ...
        - name: kf_metrics_rollup_300_topic
          partitions: <same as kf_metrics_rollup_topic>
          replicationFactor: <same as kf_metrics_rollup_topic>  # only if set there
          minInSyncReplicas: <same as kf_metrics_rollup_topic>  # only if set there
        - name: kf_metrics_rollup_1800_topic
          partitions: <same as kf_metrics_rollup_topic>
          replicationFactor: <same as kf_metrics_rollup_topic>  # only if set there
          minInSyncReplicas: <same as kf_metrics_rollup_topic>  # only if set there
    yaml
  • Check minInSyncReplicas. Each topic now uses its own value, or 1 if unset, and the upgrade applies it to existing topics. Set it on every topic that needs more than 1, but never above the topic’s replication factor, or writes fail.

To keep some rollups longer than others, see Retention.

Defaults Updated

Check these settings in your custom-values.yaml file:

  • Performance logs are enabled by default. To keep them disabled, add the following. If you enabled them for 4.3.0, you can remove that setting.

    global:
      EnablePerfLogs: false
    yaml
  • Pinot graceful termination is enabled by default for the realtime servers of the main pinot instance, so rolling upgrades and restarts can take up to 5 more minutes per pod. To keep it disabled, add the following. If you enabled it under pinot for 4.3.0, you can remove that setting. Isolated Pinot instances, such as pinot-logs or pinot-metrics, still default to disabled; keep any enabled: true setting under them. See Pinot Graceful Termination.

    pinot:
      server:
        realtime:
          forceCommitOnShutdown:
            enabled: false
    yaml
  • Query memory protection is enforced by default. The storage servers and query brokers stop a query that allocates more than 25% of the heap while heap usage is above 75%, holds more than 10% of the direct memory, or uses the most memory when heap usage passes 96% or direct memory usage passes 90%. To log these queries without stopping them, add the following:

    pinot:
      broker:
        oomAccountingEnabled: false
      server:
        oomAccountingEnabled: false
    yaml

    If your cluster uses stream isolation, add the same block under each isolated instance, for example pinot-logs. See Pinot Stream Isolation.

  • Grafana-managed recording rules no longer run by default. If you created recording rules in Grafana, add the following, or they stop evaluating. Recording rules defined in Kloudfuse are not affected.

    grafana:
      grafana.ini:
        recording_rules:
          enabled: true
    yaml
  • Rollup merges delete legacy resolutions. Merges of the kf_metrics_rollup table now delete rows at the legacy resolutions 600, 3600, and 14400 seconds. If your deployment wrote rollups at 600 seconds, set the following before any rollup merge runs, or the merge deletes your 600-second rollup history. See Merge the metrics rollup table.

    global:
      metrics:
        legacyRollupIntervalSecs: 600
    yaml
Size Metrics Topic Retention

Each kf_metrics segment now holds more data (see Smaller Metric Storage), so open segments take about 3.5 times longer to fill and seal. When a real-time storage server restarts, it reads each open segment again from Kafka, starting at the segment’s first record. If Kafka has already deleted that record, the data is lost. Before you upgrade, size the kf_metrics_topic retention so that Kafka keeps the longer segments.

Contact Kloudfuse support for exact retentionBytes and Kafka broker disk size for your cluster.

Replace kfuse with your Kloudfuse namespace in each command. Unset JMX_PORT, because the broker already uses that port. If your Kafka client listener uses SASL or TLS, add --command-config with a file that holds your client settings.

  1. Find the current retention. Look for retention.bytes in the output. It is per partition, and 10737418240 (10 GiB) is the default.

    kubectl exec -n kfuse -c kafka kafka-kraft-broker-0 -- sh -c 'unset JMX_PORT; \
      /opt/bitnami/kafka/bin/kafka-configs.sh --bootstrap-server localhost:9092 \
      --entity-type topics --entity-name kf_metrics_topic --describe --all' | grep retention.bytes
  2. Find how long Kafka keeps kf_metrics_topic data. Print the time of the oldest record in a partition. Repeat for two or three partitions, for example 0, 1, and 2:

    kubectl exec -n kfuse -c kafka kafka-kraft-broker-0 -- sh -c 'unset JMX_PORT; \
      /opt/bitnami/kafka/bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 \
      --topic kf_metrics_topic --partition 0 --offset earliest --max-messages 1 \
      --property print.timestamp=true --property print.value=false --timeout-ms 30000'

    The output is CreateTime:<milliseconds since 1970>. The time Kafka keeps data is now minus that time.

  3. Find how long one segment takes to fill. Port-forward the controller, and list the latest kf_metrics segments of a partition. Use the same partitions as in the previous step, changing "0" in the command:

    kubectl port-forward -n kfuse pinot-controller-0 9000:9000 &
    curl -s "http://localhost:9000/segments/kf_metrics?type=REALTIME" | jq -r '.[].REALTIME[]' \
      | awk -F'__' 'NF == 4 && $2 == "0" {print $3, $4}' | sort -n | tail -4

    Each line is a segment’s sequence number and the time it started (UTC). The time between two consecutive segments is the current fill time. Compute the new retention below for each partition you measured, and use the largest result. Do not combine the time kept on one partition with the fill time of another.

  4. Compute the new retention. Kafka must keep 3.5 times the current fill time, plus 2 hours for sealing the segment and catching up after a restart:

    required time      = 3.5 × fill time + 2 hours
    new retentionBytes = current retentionBytes × required time ÷ time Kafka keeps data

    Use the new retentionBytes, at least twice the current value, rounded up to a whole GiB.

    For example, if 10 GiB keeps 2 hours and a segment fills in 1 hour, Kafka must keep 3.5 + 2 = 5.5 hours, so the new retention is 10 GiB × 5.5 ÷ 2 = 27.5 GiB, rounded up to 28 GiB.

    Log data is also stored more compactly, about 1.3 times. Repeat these steps for kf_logs_topic and the kf_logs table, with 1.3 instead of 3.5.

  5. Set retentionBytes on kf_metrics_topic in global.kafkaTopics, in bytes per partition, and on kf_logs_topic if it needs more. The retentionBytes setting is new in the 4.4.0 chart. Before the real-time storage servers restart, the upgrade applies it to the existing topic. Removing retentionBytes later does not reset the topic’s retention.

    global:
      kafkaTopics:
        - name: kf_metrics_topic
          partitions: <unchanged>
          replicationFactor: <unchanged>
          minInSyncReplicas: <unchanged>
          retentionBytes: 30064771072   # 28 GiB in the example above
    yaml

    Make sure the brokers have disk for the larger retention first; see Increase Kafka Broker Disk.

Increase Kafka Broker Disk

Before you upgrade, make sure the Kafka brokers have room for the two new rollup topics and for the larger retention from Size Metrics Topic Retention, or they can run out of disk.

The two new rollup topics start filling as soon as the upgrade finishes, while kf_metrics_rollup_topic keeps the records it already holds. Each Kafka partition keeps up to 10 GiB by default. Each partition of the new rollup topics keeps at least that much, and more if you set a large retentionBytes on kf_metrics_topic. Here P_raw and P_rollup are the partition counts of kf_metrics_topic and the rollup topic:

5-minute topic retention  = max(10 GiB, kf_metrics_topic retentionBytes × P_raw ÷ P_rollup ÷ 10 + 7.32 GiB)
30-minute topic retention = max(10 GiB, kf_metrics_topic retentionBytes × P_raw ÷ P_rollup ÷ 60 + 7.32 GiB)

With equal partition counts, both stay at 10 GiB unless kf_metrics_topic keeps more than about 27 GiB per partition. The topic-creation Job log prints the values it sets.

For each topic, the partitions per broker are roundup(partitions × replicationFactor ÷ number of brokers). Use the topic’s replicationFactor, 1 if unset, or 2 if global.multiAzDeployment.enabled is true. Round up, because Kafka places whole partitions. Each broker then needs this much free space, where the × 1.10 covers Kafka deleting a whole log file at a time:

new rollup topics:  (partitions per broker of kf_metrics_rollup_topic) × (5-minute + 30-minute topic retention) × 1.10
kf_metrics_topic:   (partitions per broker of kf_metrics_topic) × (new retentionBytes − current retentionBytes) × 1.10

Use the current retentionBytes you found in Size Metrics Topic Retention. Add a line like the kf_metrics_topic one for kf_logs_topic if you raise its retention.

For example, with 12 partitions for each topic, replicationFactor: 1, and 3 brokers, each broker holds 4 partitions of each topic. With 28 GiB on kf_metrics_topic, the 5-minute topic keeps 2.8 + 7.32 = 10.12 GiB and the 30-minute topic 10 GiB, so the new rollup topics need 4 × 20.12 GiB × 1.10 = 88.5 GiB, and raising kf_metrics_topic from 10 GiB to 28 GiB needs 4 × 18 GiB × 1.10 = 79.2 GiB, so each broker needs about 168 GiB free.

Check the free space on each broker. Replace kfuse with your Kloudfuse namespace, and repeat for every kafka-kraft-broker pod:

kubectl exec -n kfuse -c kafka kafka-kraft-broker-0 -- df -h /bitnami/kafka

If any broker has less free space than it needs, increase the broker PVC size before you upgrade. A Helm upgrade cannot resize the PVCs of an existing StatefulSet, so resize them first as described in Increase existing PVC size, with kafka-kraft-broker as the StatefulSet name. Then set the same size in your custom-values.yaml file, or the upgrade fails:

kafka-kraft:
  broker:
    persistence:
      size: <new size>
yaml

For the full sizing formula, see Sizing Kafka PVCs.

Save the Legacy Rollup Topic Settings

Before your first upgrade attempt, save the current settings of kf_metrics_rollup_topic, whether you upgrade with kfuse-upgrade.sh or Helm. You need them if you roll back; see Before Rolling Back Below 4.4.0. Replace kfuse with your Kloudfuse namespace. The command writes the file only if it does not exist yet and kubectl succeeds, so a retry never replaces the original:

f=kf_metrics_rollup_topic-before-4.4.0.txt
[ -e "$f" ] && echo "$f already exists; keeping it" || {
  kubectl exec -n kfuse -c kafka kafka-kraft-broker-0 -- sh -c 'unset JMX_PORT; \
    /opt/bitnami/kafka/bin/kafka-configs.sh --bootstrap-server localhost:9092 \
    --entity-type topics --entity-name kf_metrics_rollup_topic --describe' > "$f.tmp" \
  && [ -s "$f.tmp" ] && mv "$f.tmp" "$f" && echo "saved $f"; }

With external Kafka, run the same kafka-configs.sh --describe from a host that can reach your Kafka cluster, with your bootstrap server. If your clients use SASL or TLS, add --command-config <client.properties> with your client settings after the bootstrap server; for a plaintext listener, run the command as shown. It saves the output to the same file, with the same rule: write it only if the file does not exist yet:

f=kf_metrics_rollup_topic-before-4.4.0.txt
[ -e "$f" ] && echo "$f already exists; keeping it" || {
  kafka-configs.sh --bootstrap-server <bootstrap-server> \
    --entity-type topics --entity-name kf_metrics_rollup_topic --describe > "$f.tmp" \
  && [ -s "$f.tmp" ] && mv "$f.tmp" "$f" && echo "saved $f"; }

Keep this file until you no longer need to roll back, including across upgrade retries. If a retry starts after a failed attempt and the file is missing, do not create it then, because the topic may already have 4.4.0 settings. Ask Kloudfuse support instead.

Scale Down the Metrics Transformer

If you upgrade with kfuse-upgrade.sh (see Upgrade with kfuse-upgrade.sh), skip this step and the next one: the script scales down the metrics transformer and flushes the rollup table before it runs helm upgrade, and scales the transformer back up if anything fails. Do both steps yourself only for a Helm upgrade without the script.

Do this step and the next one immediately before you run the upgrade. Skip both only if rollups are already disabled on the running deployment, so that this command reports that the StatefulSet is not found. If you are setting global.metrics.rollupEnabled: false in this upgrade, do both steps.

kubectl get statefulset metrics-transformer -n kfuse

Scale the metrics transformer to 0 so that it stops writing rollups to kf_metrics_rollup_topic. Replace kfuse with your Kloudfuse namespace in each command.

  1. Note the current number of replicas, so you can restore it if the upgrade does not complete:

    kubectl get statefulset metrics-transformer -n kfuse -o jsonpath='{.spec.replicas}'
  2. Scale the metrics transformer to 0:

    kubectl scale statefulset metrics-transformer -n kfuse --replicas=0
  3. Wait until every metrics transformer pod has stopped. kubectl scale returns before the pods terminate, and a terminating pod can still write rollups. This command returns only when kubectl succeeds and finds no pods; if kubectl fails, it keeps retrying:

    until pods=$(kubectl get pods -n kfuse -l app.kubernetes.io/name=metrics-transformer -o name) && [ -z "$pods" ]; do sleep 5; done

    Incoming metrics wait in Kafka while the transformer is stopped, so continue with the next step and the upgrade without delay. A successful upgrade scales the metrics transformer back up. If the upgrade fails or you cancel it, scale the metrics transformer back to the number of replicas you noted:

    kubectl scale statefulset metrics-transformer -n kfuse --replicas=<noted replicas>

    If you then retry the upgrade, repeat this step and the next one first.

Flush the Legacy Metrics Rollup Topic

After the upgrade, nothing writes to kf_metrics_rollup_topic. Rollups still in server memory from it are written to disk within 7 days by default, but are lost if a real-time storage server restarts after those records leave Kafka. Write them to disk now, after every metrics transformer pod has stopped and before you upgrade, with the flush-rollup command of kfuse-upgrade.sh (see Download the script). It runs on Release 4.2.4 and Release 4.3.0, and only flushes; it does not scale the metrics transformer:

./kfuse-upgrade.sh flush-rollup -n kfuse

The flush waits until the kf_metrics_rollup table has read everything in kf_metrics_rollup_topic, pauses consumption so its open segments are written to disk, and then resumes. If anything fails or you interrupt it, it resumes consumption before it exits. Waiting can take several minutes.

Post-Upgrade Steps

Check Kafka Topic Retention

If you set retentionBytes in Size Metrics Topic Retention, confirm that the topic has it. Replace kfuse with your Kloudfuse namespace:

kubectl exec -n kfuse -c kafka kafka-kraft-broker-0 -- sh -c 'unset JMX_PORT; \
  /opt/bitnami/kafka/bin/kafka-configs.sh --bootstrap-server localhost:9092 \
  --entity-type topics --entity-name kf_metrics_topic --describe'

The output must include retention.bytes= with the value you set, for example retention.bytes=30064771072. Check kf_logs_topic the same way if you set it there.

Before Rolling Back Below 4.4.0

The 4.4.0 upgrade may set short retention and segment settings on kf_metrics_rollup_topic so that Kafka frees its disk. A helm rollback below 4.4.0 does not remove them, and releases before 4.4.0 write rollups to this topic again, so rollups that are not read within minutes are lost.

./kfuse-upgrade.sh rollback removes them for you. When it rolls back from 4.4.0 or later to a release before 4.4.0, it deletes retention.bytes, retention.ms, segment.bytes, and segment.ms from kf_metrics_rollup_topic before it starts the rollback. If it cannot, it stops without rolling back.

  • The script reads the client settings from the broker for a PLAINTEXT listener, or a SASL_PLAINTEXT listener with the PLAIN mechanism. For TLS, SASL_SSL, or any other SASL mechanism, pass --kafka-command-config <client.properties>, a file with the security.protocol, SASL, and TLS settings your clients use. If the script cannot authenticate, it stops before rolling back and says so.

  • With external Kafka, restore or remove the settings yourself as shown below, using the external snapshot from Save the Legacy Rollup Topic Settings and your bootstrap server, then run the rollback with --skip-rollup-topic-reset.

  • After the rollback, if any of the four was set in kf_metrics_rollup_topic-before-4.4.0.txt, set it back to the saved value with --add-config.

If you roll back without kfuse-upgrade.sh, list the topic’s settings first:

kubectl exec -n kfuse -c kafka kafka-kraft-broker-0 -- sh -c 'unset JMX_PORT; \
  /opt/bitnami/kafka/bin/kafka-configs.sh --bootstrap-server localhost:9092 \
  --entity-type topics --entity-name kf_metrics_rollup_topic --describe'

Compare the output with kf_metrics_rollup_topic-before-4.4.0.txt, the file you saved before the upgrade, for each of retention.bytes, retention.ms, segment.bytes, and segment.ms:

  • The setting was in the saved file: set it back to the saved value with --add-config.

  • The setting was not in the saved file but is listed now: remove it with --delete-config.

For example, if none of the four was set before the upgrade and all four are listed now:

kubectl exec -n kfuse -c kafka kafka-kraft-broker-0 -- sh -c 'unset JMX_PORT; \
  /opt/bitnami/kafka/bin/kafka-configs.sh --bootstrap-server localhost:9092 \
  --entity-type topics --entity-name kf_metrics_rollup_topic \
  --alter --delete-config retention.bytes,retention.ms,segment.bytes,segment.ms'

If you did not save the file, ask Kloudfuse support before you remove these settings.

Metric Shaping Rules With Label Filters

Create shaping rules with label filters only after every ingester is running Release 4.4.0.

Upgrade to 4.3.0

Pre-Upgrade Steps

Upgrade From 4.2.4

Upgrade to Release 4.2.4 before upgrading to Release 4.3.0. Downgrading from 4.3.0 is not supported; the chart refuses to install an earlier version over it.

Move ui.config to global.uiConfig (Breaking Change)

Both the existing UI and the new Kloudfuse UI now read their settings from global.uiConfig. The upgrade fails if your custom-values.yaml file still sets ui.config. Move each key and remove ui.config:

# Before
ui:
  config:
    <key>: <value>

# After
global:
  uiConfig:
    <key>: <value>
yaml
Add the Archive Topic to Your Kafka Topics (Breaking Change)

Archives are now written directly from the ingest stream through a new Kafka topic, kf_logs_archive_v2_topic. If archiving is enabled and your custom-values.yaml file overrides global.kafkaTopics, add this topic to the list, or the upgrade fails. The topic carries every ingested log line, so give it the same partition count as logs_ingest_topic:

global:
  kafkaTopics:
    - name: kf_logs_archive_v2_topic
      partitions: <same as logs_ingest_topic>
      replicationFactor: <same as logs_ingest_topic>
      minInSyncReplicas: <same as logs_ingest_topic>
yaml
Plan a Maintenance Window

The query engine servers restart during the upgrade (see Longer Pinot Server Pod Termination). Until they are back, expect partial query results, ingestion lag, and alerts that report errors or no data. Silence alerts for the duration of the upgrade.

Grant the Admin Role for Archive and Hydration Management

With RBAC enabled, Release 4.3.0 requires the Admin role for creating, editing, starting, stopping, or deleting archives and for starting, pausing, resuming, or cancelling hydration jobs (see Admin-Only Archive and Hydration Management). Before upgrading, grant the Admin role to the users and service accounts that manage archives or run hydration jobs, so they keep that access after the upgrade. Grant it deliberately: the Admin role also gives unrestricted access to all telemetry and to user and policy administration (see Role Permissions). Listing and progress views are unaffected.

Enable Performance Logs

The Expensive Queries control-plane dashboard and the query counts and last-queried times on the Metrics Usage screen are built from performance logs, which are disabled by default in Release 4.3.0. Without them, the dashboard stays empty and Metrics Usage shows only which dashboards, alerts, and rules reference each metric. To enable them, set EnablePerfLogs in your custom-values.yaml file; performance logs also require RBAC and audit logs, which are enabled by default:

global:
  EnablePerfLogs: true
yaml

See Enabling Performance Logs. Performance logs are enabled by default starting with Release 4.4.0.

Post-Upgrade Steps

New Kloudfuse UI

The new Kloudfuse UI is available at the /f path after the upgrade, with no configuration required. The existing UI remains the default experience; each user can switch individually, and the choice is remembered in the browser.

Longer Pinot Server Pod Termination

Pinot server pods now allow up to 21.5 minutes to drain in-flight queries and offload segments before terminating, instead of being force-killed after 30 seconds; if the graceful-termination segment commit (see Pinot Graceful Termination) is enabled, the commit timeout is added on top (5 more minutes by default). Rolling upgrades and restarts can therefore take longer than before; pods still terminate as soon as the drain completes.

Performance Log Fields

Performance log entries from every query service now use the unified field set described in Performance Log Fields (see Unified Performance Logs). Each entry now carries the emitting service as its source; the previous source="kf-performance-log" filter matches no new entries, so use @perf_log="true" instead. Saved queries, scheduled views, or dashboards built on the previous fields — for example a duration parsed from a string rather than read from the integer duration_ms facet — also need to be updated.

Log Normalization Moves to Ingest

Log normalization (remap) now runs in the ingest path by default (global.logs.remap.enabled: true) instead of in the log parser. The Logs Remap page is editable only when global.logs.remap.configDb.enabled is also true. See Log Source Normalization (Remap).

Maximum Log Line Length

Log lines longer than 100 KB are now truncated at ingest. The previous limit was 1 MB.

Term Search Behavior Change (Gradual)

Release 4.3.0 changes how log lines are split into searchable terms (see More Intuitive Term Search). The change is forward-only: it applies to log data written after the upgrade, while previously written data keeps the old behavior until it ages out of retention. During that window the same search can match new logs and miss older ones.

Upgrade to 4.2.4

Pre-Upgrade Steps

Delete the Transformer Deployments

In Release 4.2.4, the logs, metrics, and trace transformers change from deployments to stateful sets, and they divide Kafka partitions among their pods using a new scheme that is not compatible with the previous one. The existing pods must be fully stopped before you upgrade, rather than replaced by a rolling update.

Delete the transformer deployments and wait for their pods to terminate. The upgrade recreates them as stateful sets.

kubectl delete deployment -n <namespace> --cascade=foreground \
  logs-transformer metrics-transformer trace-transformer
Telemetry processing pauses between the delete and the completion of the upgrade. Incoming data continues to be buffered and is processed once the new pods start.

Upgrade to 4.2.3

There are no specific pre-upgrade or post-upgrade steps for upgrading to Release 4.2.3.

Upgrade to 4.2.2

Pre-Upgrade Steps

GCP Logs Pub/Sub Subscriptions Now a List (Breaking Change)

Release 4.2.2 configures GCP Pub/Sub log collection with a subscriptions list under global.gcpConfig.pubsub, replacing the previous single subscriptionId field. Update the pubsub section of your custom-values.yaml file to the new list format before upgrading:

global:
  gcpConfig:
    secretName: "kfuse-gcp-credentials"
    projectId: "<your-gcp-project-id>"
    pubsub:
      enabled: true
      subscriptions: (1)
        - projectId: "<your-gcp-project-id>" (2)
          subscriptionId: "kloudfuse-gcp-subscription"
yaml
1 Changed: subscriptions replaces the previous single subscriptionId field and takes a list. Add one entry per subscription — and add more entries to consume logs from multiple subscriptions, including subscriptions in different GCP projects, using the same secret.
2 Changed: each subscription entry carries its own projectId. Pub/Sub log ingestion fails to start for any subscription that is missing it.

For full configuration details, see Configure Kloudfuse via Helm.

Post-Upgrade Steps

Review Saved Queries That Use parse

Release 4.2.2 rejects an anchored parse pattern whose alias count does not match the number of extractions. Queries of this form were previously accepted and silently dropped extractions or left aliases empty. Saved searches, scheduled searches, and alerts using these patterns fail after upgrading and must be corrected.

Update MCP Clients That Call search_logs

Release 4.2.2 makes FuseQL query_logs the default logs tool in the MCP server. The legacy LogQL tools search_logs and query_log_metrics are no longer on the default tool surface. Clients that call them must either move to query_logs or request the legacy toolset explicitly with ?toolsets=logql.

Update MCP Clients That Decode Prometheus Responses

Release 4.2.2 changes the response shape of the query_prometheus, search_prometheus_label_names, and search_prometheus_label_values tools. These tools now return parsed objects rather than JSON-encoded strings. Clients that decoded the previous string response must be updated. Other tool families are unchanged.

Upgrade to 4.2.1

Pre-Upgrade Steps

Add kf_metrics_staging_topic Kafka Topic

Release 4.2.1 requires a new Kafka topic. Before upgrading, add the following entry to global.kafkaTopics in your custom-values.yaml:

global:
  kafkaTopics:
    - name: kf_metrics_staging_topic
      partitions: 1
      replicationFactor: 1
yaml

Upgrade to 4.2.0

Pre-Upgrade Steps

Metric Shaping Kafka Topic

Release 4.2.0 introduces the Metric Shaping Rules feature, which requires the kf_metrics_staging_topic Kafka topic. Before upgrading, ensure that this topic is included in your global.kafkaTopics section in the custom-values.yaml file:

        - name: kf_metrics_staging_topic
          partitions: <number-of-nodes>
          replicationFactor: 1
yaml
Set the number of partitions to the number of nodes in your cluster.
Archive Writer Kafka Topic (Conditional)

If you plan to enable the new archive writer (see Archive Writer Disabled by Default), ensure that the kf_logs_archive_v2_topic Kafka topic is included in your global.kafkaTopics section in the custom-values.yaml file:

        - name: kf_logs_archive_v2_topic
          partitions: <number-of-nodes>
          replicationFactor: 1
yaml
Set the number of partitions to the number of nodes in your cluster.
AWS CloudWatch Regions (Breaking Change)

Starting in Release 4.2.0, the awsRegions list in Helm values defaults to an empty list. Customers using AWS CloudWatch metrics scraping must now explicitly specify the regions they want to scrape (opt in) — either globally under ingester.config.awsRegions, or per scraper in a specific awsRoleArns entry’s regions list. See Helm Values for details.

Post-Upgrade Steps

Query Scheduling Enabled by Default

Query scheduling is enabled by default in Release 4.2.0. Administrators can configure per-user, per-group, and per-service-account query priorities — including the new blocked priority, which rejects matching queries instead of delaying or queueing them — from the admin UI. To disable query scheduling entirely, set the following in your custom-values.yaml:

global:
  queryScheduler:
    enabled: false
yaml
Archive Writer Disabled by Default

The new archive writer is disabled by default. It can be turned on per deployment when you are ready — contact Kloudfuse support to opt in. Enabling it requires the kf_logs_archive_v2_topic Kafka topic; see Archive Writer Kafka Topic (Conditional) in the pre-upgrade steps.

Scheduled Searches Disabled by Default

Scheduled searches are disabled by default and can be enabled on request — contact Kloudfuse support to enable the feature for your tenant.

Upgrade to 4.1.0

Pre-Upgrade Steps

Set events-query-service.config.rbacdb.user (Externally-Managed Postgres Only)

If your configDB is hosted on an externally-managed Postgres instance (AWS RDS, GCP Cloud SQL, Azure Database for PostgreSQL) where the application user is not the default postgres, you must add an explicit events-query-service.config.rbacdb.user override to your custom-values.yaml. The events-query-service chart currently ships with a hardcoded rbacdb.user: postgres default that masks the global.configDB.username fallback, so without this override events-query-service connects to rbacdb as postgres and fails with no pg_hba.conf entry for host …​, user "postgres", database "rbacdb". Skip this step if global.configDB.username is postgres (the default).

events-query-service:
  config:
    rbacdb:
      user: <your-configdb-app-username>  # match global.configDB.username
yaml

This step will not be required once events-query-service v0.1.0-<TBD> ships the chart-side fix; the override can be removed in a follow-up release.

Post-Upgrade Steps

Migrate Ingestion Auth Keys to the UI (Optional, Recommended)

Starting in 4.1.0, ingestion API keys and their optional additional labels can be managed from the Kloudfuse UI. Open Admin > Settings, then click Configure on the Auth key labels card. The legacy YAML configuration (kfuse-auth-ingest secret + ingester.config.authKeyAdditionalLabels) continues to work but is deprecated. YAML-sourced entries appear in the UI as read-only.

After upgrading, recreate each YAML-managed entry through the UI (reusing the existing token to avoid agent reconfiguration), then delete the legacy YAML configuration:

kubectl delete secret kfuse-auth-ingest -n <namespace> (1)
1 Replace <namespace> with the namespace of your Kloudfuse deployment.

Remove the ingester.config.authKeyAdditionalLabels block from custom-values.yaml and re-apply Helm values, then restart config-mgmt-service:

kubectl rollout restart deploy/config-mgmt-service -n <namespace> (2)
2 Replace <namespace> with the namespace of your Kloudfuse deployment.

For full migration steps and a placeholder helper script, see Migrate YAML-managed Auth Keys to the UI.

Upgrade to 4.0.2

Pre-Upgrade Steps

No special pre-upgrade steps are required for this release.

4.0.1

Pre-Upgrade Steps

TLS Certificate Key Type Check (Required for Envoy Gateway deployments)

Release 4.0.1 upgrades the Envoy proxy to v1.36 with FIPS-compliant cryptography. The FIPS proxy rejects RSA private keys for TLS certificates delivered via SDS. All TLS secrets should be checked and any RSA certificates should be recreated as ECDSA.

If your deployment uses AWS ACM (tls.awsAcmEnabled: true), TLS is terminated at the NLB and Envoy never loads the listener certificate. You only need to check the internal envoy certificates (steps 1-2), not the listener certificate.
  1. Scan all TLS secrets for RSA keys:

    for secret in $(kubectl get secrets -n <namespace> --field-selector type=kubernetes.io/tls -o jsonpath='{.items[*].metadata.name}'); do
      KEY_TYPE=$(kubectl get secret $secret -n <namespace> -o jsonpath='{.data.tls\.key}' | base64 -d | openssl pkey -noout -text 2>/dev/null | head -1)
      if echo "$KEY_TYPE" | grep -q "2048\|4096\|3072"; then
        echo "RSA: $secret — needs recreation"
      else
        echo "ECDSA: $secret — OK"
      fi
    done (1)
    1 Replace <namespace> with the namespace of your Kloudfuse deployment.
  2. Delete internal envoy certificates (certgen certs):

    These are regenerated automatically by the certgen hook during the helm upgrade. The 4.0.1 certgen generates ECDSA P-256 keys.

    kubectl delete secret envoy envoy-gateway envoy-rate-limit -n <namespace> (1)
    1 Replace <namespace> with the namespace of your Kloudfuse deployment. Some of these secrets may not exist depending on your configuration — errors for missing secrets can be ignored.
  3. Proceed with the helm upgrade to 4.0.1.

Post-Upgrade Steps

TLS Listener Certificate Reissue (Required for cert-manager deployments)

After the upgrade, the Gateway resource has ECDSA annotations (cert-manager.io/private-key-algorithm: ECDSA). If your listener TLS certificate was RSA (identified in the pre-upgrade check), it must be deleted and reissued as ECDSA.

Skip this section if you use AWS ACM (tls.awsAcmEnabled: true) or if your listener certificate was already ECDSA.
  1. Verify the Gateway has ECDSA annotations:

    kubectl get gateway kfuse -n <namespace> -o yaml | grep -i 'private-key' (1)
    1 Replace <namespace> with the namespace of your Kloudfuse deployment.

    You should see:

    cert-manager.io/private-key-algorithm: ECDSA
    cert-manager.io/private-key-size: "256"
    yaml

    If these annotations are not present, add them manually:

    kubectl annotate gateway kfuse -n <namespace> \
      cert-manager.io/private-key-algorithm=ECDSA \
      cert-manager.io/private-key-size="256" --overwrite (2)
    2 Replace <namespace> with the namespace of your Kloudfuse deployment. If you have an internal gateway (kfuse-internal), repeat for that gateway as well.
  2. Delete the listener TLS certificate:

    kubectl delete secret <tls-secret-name> -n <namespace> (1)
    1 Replace <tls-secret-name> with your TLS secret name (default is letsencrypt-ingress-tls). Check your tls.secretName value if you use a custom name.

    cert-manager will automatically reissue the certificate as ECDSA within 30-60 seconds.

  3. Verify the new certificate is ECDSA:

    kubectl get secret <tls-secret-name> -n <namespace> \
      -o jsonpath='{.data.tls\.key}' | base64 -d | \
      openssl pkey -noout -text 2>/dev/null | head -1 (1)
    1 Replace <tls-secret-name> and <namespace>.

    Should show Private-Key: (256 bit) (ECDSA P-256).

  4. Restart the Envoy proxy to load the new certificate:

    kubectl rollout restart deploy/envoy -n <namespace> (1)
    1 Replace <namespace> with the namespace of your Kloudfuse deployment. If you have an internal envoy (envoy-internal), restart that as well.
  5. Verify HTTPS is working:

    curl -sk https://<your-hostname> -o /dev/null -w "%{http_code}"

    Expected response: 401 (redirects to login).

If you use a BYOC (Bring Your Own Certificate) RSA cert, cert-manager cannot reissue it. You must obtain an ECDSA P-256 certificate from your certificate authority and update the Kubernetes TLS secret, or switch to AWS ACM for TLS termination.

Why is this needed?

The Envoy proxy FIPS build uses SafeLogic CryptoComply for cryptographic operations. When a TLS certificate is delivered to the proxy via SDS (Secret Discovery Service), the private key is imported into the FIPS cryptographic module. SafeLogic’s implementation runs a Pairwise Consistency Test (PCT) on RSA key import, which fails. ECDSA keys are not affected.

Internal certificates used for communication between Envoy components (certgen/xDS certs) are loaded from files and work with RSA, but are recreated as ECDSA for consistency.

TLS Setup Envoy loads private key via SDS? Action needed?

AWS ACM (NLB terminates TLS)

No

Pre-upgrade only (certgen certs)

cert-manager (Envoy terminates TLS)

Yes

Pre-upgrade + Post-upgrade (all certs)

BYOC (Envoy terminates TLS)

Yes

Pre-upgrade + reissue ECDSA cert from CA

4.0.0

Pre-Upgrade Steps

Hydration Service Deployment change (Required)

K8s deployment type for hydration-service has changed from Deployment to StatefulSet. Before upgrading to 4.0, delete the existing Deployment and ConfigMap.

kubectl delete deployment -n <namespace> hydration-service (1)
kubectl delete cm -n <namespace> hydration-service (1)
1 Replace <namespace> with the namespace of your Kloudfuse deployment.
Envoy Gateway Migration (Optional)

Starting in 4.0.0, Kloudfuse supports Envoy Gateway as an alternative to NGINX Ingress. Existing deployments can optionally migrate using a zero-downtime 3-step migration process. See Configure Envoy Ingress for details.

AWS CloudWatch Namespaces (Breaking Change)

Starting in 4.0.0, the awsNamespaces list in Helm values defaults to an empty list. Customers using AWS CloudWatch metrics scraping must explicitly list the namespaces they want to scrape. Before upgrading, add the desired namespaces under ingester.config.awsNamespaces in your Helm values override:

ingester:
  config:
    awsNamespaces:
      - "AWS/EC2"
      - "AWS/RDS"
      - "AWS/S3"
      - "AWS/Lambda"
      # Add other namespaces as needed
yaml

For the full list of supported namespaces, see AWS Supported Services.

Two new namespaces are now supported: AWS/Bedrock and AWS/QBusiness. If you enable these, ensure your AWS IAM scraper role policy includes the required permissions: bedrock:ListFoundationModels, bedrock:ListTagsForResource, qbusiness:ListApplications, qbusiness:GetApplication, qbusiness:ListTagsForResource.

Post-Upgrade Steps

Pinot STS Rollout Restart

After the upgrade, wait for the setup-pinot job to complete, then perform a rollout restart of the Pinot STS (StatefulSet) to pick up the updated schema and table configuration.

kubectl rollout restart statefulset/pinot-server-offline
kubectl rollout restart statefulset/pinot-server-realtime
kubectl rollout restart statefulset/pinot-broker
kubectl rollout restart statefulset/pinot-controller
kubectl rollout restart statefulset/pinot-minion

3.5.3-p1

There are no specific pre-upgrade or post-upgrade steps for upgrading to Release 3.5.3-p1.

3.5.3

Pre-Upgrade Steps

Metrics Transformer GOMEMLIMIT

Multi-resolution rollup increases memory usage in the metrics transformer. Review and increase the GOMEMLIMIT setting for the metrics transformer if needed, especially for high-cardinality deployments.

Kafka Rollup Topic

Metrics rollup is enabled by default in 3.5.3. Before upgrading, ensure that kf_metrics_rollup_topic is included in your Kafka topics list in the Helm values. Specify the same number of partitions as the existing kf_metrics_topic.

RUM Vitals Kafka Topic (Conditional)

If RUM is enabled in your deployment, ensure that kf_rum_vitals_topic is included in your Kafka topics list in the Helm values. Specify the same number of partitions as the existing kf_rum_views_topic.

Legacy Rollup Interval (Conditional)

If you were using a non-default rollup interval before 3.5.3 (for example, 600s instead of the default 300s), set the legacy interval so that pre-3.5.3 rollup data is attributed to the correct resolution:

global:
  metrics:
    legacyRollupIntervalSecs: 600
yaml

Post-Upgrade Steps

Multi-Rollup Resolution

After the upgrade, wait for the setup-pinot job to complete, then restart the Pinot STS (StatefulSet) to pick up the new rollup schema and table configuration. Existing metrics data is automatically compatible with multi-rollup resolution.

Pod Security Configuration (Optional)

Review your Helm values if you use custom security configurations. All services now run as non-root users by default and support configurable service accounts and security context. Existing deployments without custom security settings are unaffected.

Scheduled Views

Scheduled views have been redesigned. You must recreate your scheduled views after upgrading. Data continuity from the previous implementation cannot be guaranteed.

3.5.2-p2

There are no specific pre-upgrade or post-upgrade steps for upgrading to Release 3.5.2-p2.

3.5.2-p1

There are no specific pre-upgrade or post-upgrade steps for upgrading to Release 3.5.2-p1.

3.5.2

Pre-Upgrade Steps

There are no specific pre-upgrade steps for upgrading to Release 3.5.2.

Post-Upgrade Steps

Container Image Signature Verification (Optional)

Starting with 3.5.2, all Kloudfuse container images and Helm charts are signed. You can optionally verify image signatures before deployment.

Folder Permissions

If you use folder-based organization for dashboards and alerts, review folder permissions after upgrade to ensure appropriate access levels are configured.

Logs Parser Restart

After upgrading to 3.5.2, you must restart the logs-parser to ensure proper functionality.

The following commands use kfuse as the default namespace. Replace with your actual namespace if different.
  1. Scale down the logs-parser:

    kubectl scale sts logs-parser -n kfuse --replicas=0
    bash
  2. Verify that all logs-parser pods are terminated before proceeding:

    kubectl get pods -n kfuse -l app=logs-parser
    bash
  3. Scale up the logs-parser to match the numNodes value configured in your custom values YAML:

    kubectl scale sts logs-parser -n kfuse --replicas=<numNodes>
    bash

3.5.1-p2

There are no specific pre-upgrade or post-upgrade steps for upgrading to Release 3.5.1-p2.

3.5.1-p1

There are no specific pre-upgrade or post-upgrade steps for upgrading to Release 3.5.1-p1.

3.5.1

There are no specific pre-upgrade or post-upgrade steps for upgrading to Release 3.5.1.

3.5.0

Pre-Upgrade Steps

To support improved management of RUM session recordings, ensure that your global.kafkaTopics section in the custom-values.yaml file contains the following additional topic:

        - name: kf_rum_expired_sessions_topic
          partitions: 1
          replicationFactor: 1
yaml