Deploy Grafana Mimir with Jsonnet and Tanka on Grafana Labs

Deploy Grafana Mimir with Jsonnet and Tanka

Wed, 03 Jun 2026 09:01:40 +0200

Deploy Grafana Mimir with Jsonnet and Tanka

You can use Tanka and jsonnet-bundler to generate Kubernetes YAML manifests from the jsonnet files.

Install tanka and jb:

Follow the steps at https://tanka.dev/install. If you have go installed locally you can also use:

# make sure to be outside of GOPATH or a go.mod project
go install github.com/grafana/tanka/cmd/tk@latest
go install github.com/jsonnet-bundler/jsonnet-bundler/cmd/jb@latest

Set up a Jsonnet project, based on the example that follows:

Initialize Tanka
Install Grafana Mimir and Kubernetes Jsonnet libraries
Set up an environment

#!/usr/bin/env bash
# SPDX-License-Identifier: AGPL-3.0-only

set -e

# Initialise the Tanka.
mkdir jsonnet-example && cd jsonnet-example
tk init --k8s=1.30

# Install Mimir jsonnet.
jb install github.com/grafana/mimir/operations/mimir@main

# Use the provided example.
cp vendor/mimir/mimir-manifests.jsonnet.example environments/default/main.jsonnet

# Generate the YAML manifests.
export PAGER=cat
tk show environments/default

Generate the Kubernetes YAML manifests and store them in the ./manifests directory:

# Generate the YAML manifests:
export PAGER=cat
tk show environments/default
tk export manifests environments/default

Configure the environment specification file at environments/default/spec.json.

To learn about how to use Tanka and to configure the spec.json file, see Using Jsonnet: Creating a new project.
Deploy the manifests to a Kubernetes cluster, in one of two ways:
- Use the tk apply command.
  
  Tanka supports commands to show the diff and apply changes to a Kubernetes cluster:
  sh
```
# Show the difference between your Jsonnet definition and your Kubernetes cluster:
tk diff environments/default

# Apply changes to your Kubernetes cluster:
tk apply environments/default
```
- Use the kubectl apply command.
  
  You generated the Kubernetes manifests and stored them in the ./manifests directory in the previous step.
  
  You can run the following command to directly apply these manifests to your Kubernetes cluster:
  sh
```
# Review the changes that will apply to your Kubernetes cluster:
kubectl apply --dry-run=client -k manifests/

# Apply the changes to your Kubernetes cluster:
kubectl apply -k manifests/
```
Note
The generated Kubernetes manifests create resources in the default namespace. To use a different namespace, change the namespace configuration option in the environments/default/main.jsonnet file, and re-generate the Kubernetes manifests.

Note
Starting from Mimir 3.0, a Jsonnet-based installation uses memberlist for the HA tracker by default. No external dependencies are required. If you’re upgrading from a previous version that used etcd or Consul for the HA tracker, refer to the migration guide.

Configure Grafana Mimir to use low resources with Jsonnet

Wed, 03 Jun 2026 09:01:40 +0200

Configure Grafana Mimir to use low resources with Jsonnet

This page describes how to configure Jsonnet to deploy Grafana Mimir in a Kubernetes cluster with low CPU and memory resources available.

Anti-affinity

Given the distributed nature of Mimir, both performance and reliability are improved when pods are spread across different nodes. For example, losing multiple ingesters can cause data loss, so it’s better to distribute them across different nodes.

For this reason, by default, anti-affinity rules are applied to some Kubernetes Deployments and StatefulSets. These anti-affinity rules can become an issue when playing with Mimir in a single-node Kubernetes cluster. You can disable anti-affinity by setting the configuration values _config.<component>_allow_multiple_replicas_on_same_node.

Example: disable anti-affinity

local mimir = import 'mimir/mimir.libsonnet';

mimir {
  _config+:: {
    ingester_allow_multiple_replicas_on_same_node: true,
    store_gateway_allow_multiple_replicas_on_same_node: true,
  },
}

Resources

Default scaling of Mimir components in the provided Jsonnet is opinionated and based on engineers’ years of experience running it at Grafana Labs. The default resource requests and limits are also fine-tuned for the provided alerting rules. For more information, see Monitor Grafana Mimir.

However, there are use cases where you might want to change the default resource requests, their limits, or both. For example, if you are just testing Mimir and you want to run it on a small (possibly one-node) Kubernetes cluster, and you do not have tens of gigabytes of memory or multiple cores to schedule the components, consider overriding the scaling requirements as follows:

local k = import 'github.com/grafana/jsonnet-libs/ksonnet-util/kausal.libsonnet',
      deployment = k.apps.v1.deployment,
      statefulSet = k.apps.v1.statefulSet;
local mimir = import 'mimir/mimir.libsonnet';

mimir {
  _config+:: {
    // ... configuration values
  },

  compactor_container+: k.util.resourcesRequests('100m', '128Mi'),
  compactor_statefulset+: statefulSet.mixin.spec.withReplicas(1),

  distributor_container+: k.util.resourcesRequests('100m', '128Mi'),
  distributor_deployment+: deployment.mixin.spec.withReplicas(2),

  ingester_container+: k.util.resourcesRequests('100m', '128Mi'),
  ingester_statefulset+: statefulSet.mixin.spec.withReplicas(3),

  querier_container+: k.util.resourcesRequests('100m', '128Mi'),
  querier_deployment+: deployment.mixin.spec.withReplicas(2),

  query_frontend_container+: k.util.resourcesRequests('100m', '128Mi'),
  query_frontend_deployment+: deployment.mixin.spec.withReplicas(2),

  store_gateway_container+: k.util.resourcesRequests('100m', '128Mi'),
  store_gateway_statefulset+: statefulSet.mixin.spec.withReplicas(1),

  local smallMemcached = {
    cpu_requests:: '100m',
    memory_limit_mb:: 64,
    memory_request_overhead_mb:: 8,
    statefulSet+: statefulSet.mixin.spec.withReplicas(1),
  },

  memcached_chunks+: smallMemcached,
  memcached_frontend+: smallMemcached,
  memcached_index_queries+: smallMemcached,
  memcached_metadata+: smallMemcached,
}

Configure ingest storage architecture

Wed, 03 Jun 2026 09:01:40 +0200

Configure ingest storage architecture

The ingest storage is the next generation architecture of Grafana Mimir. It decouples the Mimir read and write paths using Apache Kafka or a Kafka-compatible backend.

To enable ingest storage, set the following Jsonnet:

{
  _config+:: {
    ingest_storage_enabled: true,
  }
}

Note
The ingest storage architecture requires a production-grade Apache Kafka cluster or Kafka-compatible backend.

Warning
The ingest storage architecture requires the ruler remote evaluation to be enabled for the Mimir cluster. Refer to the Configure the Grafana Mimir ruler with Jsonnet documentation for details about the ruler’s operational modes.

Kafka connection options

The Jsonnet configures some Kafka connection parameters by default:

Kafka topic: ingest
Auto-created partitions: 1000 (when the topic doesn’t exist)
Kafka addresses: kafka.<namespace>.svc.<cluster_domain>:9092

To customize the Kafka connection configuration, override the default settings:

{
  _config+:: {
    ingest_storage_enabled: true,
  },

  // Override producer and consumer addresses for external Kafka
  ingest_storage_kafka_producer_address:: 'kafka-broker-1:9092,kafka-broker-2:9092',
  ingest_storage_kafka_consumer_address:: 'kafka-broker-1:9092,kafka-broker-2:9092',

  // Override Kafka client configuration
  ingest_storage_kafka_client_args+:: {
    'ingest-storage.kafka.topic': 'mimir-ingest',
    'ingest-storage.kafka.auto-create-topic-default-partitions': 500,
  },
}

Kafka partition sizing

The configured topic must have at least as many partitions as the number of ingesters in one zone.

Refer to Configure the Grafana Mimir Kafka backend for more details about Kafka configurations.

Configure the Grafana Mimir object storage backend with Jsonnet

Wed, 03 Jun 2026 09:01:40 +0200

Configure the Grafana Mimir object storage backend with Jsonnet

You can configure the object storage backend for all Mimir components from a single place. The minimum Jsonnet code required for this is:

{
  _config+:: {
    storage_backend: 'gcs',
    blocks_storage_bucket_name: 'blocks-bucket',
  }
}

The storage_backend option must be one of either azure, gcs, or s3. Additional configuration options are available for each one of these providers.

Amazon S3 (`s3`) storage configuration options

Amazon S3 storage can be accessed without credentials when using Amazon VPC. In this case, storage_s3_secret_access_key and storage_s3_access_key_id are optional and can be left null, as in the following example:

{
  _config+:: {
    storage_backend: 's3',
    blocks_storage_bucket_name: 'blocks-bucket',
    aws_region: 'af-south-1',
  }
}

If credentials are required, it is a good practice to keep them in secrets. In that case environment variable interpolation can be used:

{
  _config+:: {
    storage_backend: 's3',
    storage_s3_access_key_id: '$(BLOCKS_STORAGE_S3_ACCESS_KEY_ID)',
    storage_s3_secret_access_key: '$(BLOCKS_STORAGE_S3_SECRET_ACCESS_KEY)',
    aws_region: 'af-south-1',
    blocks_storage_bucket_name: 'blocks-bucket',
  }
}

Azure (`azure`) storage configuration options

Hierarchical namespace must be disabled in Azure Blob Storage. Otherwise, Grafana Mimir will leave empty directories behind after deleting blocks.

The Azure storage client requires the storage_azure_account_name and storage_azure_account_key to be configured. It is a good practice to keep them in secrets. In that case environment variable interpolation can be used:

{
  _config+:: {
    storage_backend: 'azure',
    storage_azure_account_name: '$(STORAGE_AZURE_ACCOUNT_NAME)',
    storage_azure_account_key: '$(STORAGE_AZURE_ACCOUNT_KEY)',
    blocks_storage_bucket_name: 'blocks-bucket',
  }
}

Google Cloud Storage (`gcs`) storage configuration options

There are multiple ways to configure Google Cloud Storage client. If you run Mimir on Google Cloud Platform it is possible that the environment already has the credentials configured, in that case the minimum jsonnet configuration is valid:

{
  _config+:: {
    storage_backend: 'gcs',
    blocks_storage_bucket_name: 'blocks-bucket',
  }
}

You can use the storage_gcs_service_account configuration key to provide the service account when authentication is needed. It is a good practice to keep credentials in secrets, so environment variable interpolation can be used:

{
  _config+:: {
    storage_backend: 'gcs',
    storage_gcs_service_account: '$(STORAGE_GCS_SERVICE_ACCOUNT)',
    blocks_storage_bucket_name: 'blocks-bucket',
  }
}

Alternatively, you can set the GOOGLE_APPLICATION_CREDENTIALS environment variable to point to the service account file mounted from a secret.

Configure the Grafana Mimir ruler with Jsonnet

Wed, 03 Jun 2026 09:01:40 +0200

Configure the Grafana Mimir ruler with Jsonnet

The ruler is an optional component and is therefore not deployed by default when using Jsonnet. For more information about the ruler, see Grafana Mimir ruler.

To enable it, add the following Jsonnet code to the _config section:

{
  _config+:: {
    ruler_enabled: true,
    ruler_storage_bucket_name: 'ruler-bucket-name',
  },
}

By default, the object storage backend used for the ruler will be the one set by the $._config.storage_backend option. If desired, you can override it by setting the $._config.ruler_storage_backend option. The ruler_storage_backend option must be one of either local, azure, gcs, or s3. For more information about the options available for storing ruler state, see Grafana Mimir ruler: State.

To get started, use the local client type for initial testing:

{
  _config+:: {
    ruler_enabled: true,
    ruler_storage_backend: 'local',
    ruler_local_directory: '/path/to/local/directory',
  },
}

If you are using object storage, you must set ruler_storage_bucket_name to the name of the bucket that you want to use.

Note
If ruler object storage credentials differ from the ones defined in the common section, you need to manually provide them by using additional command line arguments. For more information, refer to Grafana Mimir configuration parameters: ruler_storage.

Operational modes

The ruler has two operational modes: internal and remote. By default, the Jsonnet deploys the ruler by using the internal operational mode. For more information about these modes, see Operational modes.

To enable the remote operational mode, add the following code to the Jsonnet:

{
  _config+:: {n
    ruler_remote_evaluation_enabled: true,
  },
}

Note
To support the remote operational mode, the configuration includes three additional Kubernetes Deployments as a separate query path.

These are:

ruler-query-frontend

ruler-query-scheduler

ruler-querier

Migrate to remote evaluation

To perform a zero downtime migration from internal to remote rule evaluation, follow these steps:

Deploy the following changes to enable remote evaluation in migration mode. Doing so causes the three new and previously listed Kubernetes deployments to start. However, they will not reconfigure the ruler to use them just yet.
jsonnet
```
{
 _config+:: {
   ruler_remote_evaluation_enabled: true,
   ruler_remote_evaluation_migration_enabled: true,
 },
}
```
Check that all of pods for the following deployments have successfully started before moving to the next step:
- ruler-query-frontend
- ruler-query-scheduler
- ruler-querier
Reconfigure the ruler pods to perform remote evaluation, by deploying the following changes:
jsonnet
```
{
  _config+:: {
    ruler_remote_evaluation_enabled: true,
  },
}
```

Configure Grafana Mimir autoscaling with Jsonnet

Wed, 03 Jun 2026 09:01:40 +0200

Configure Grafana Mimir autoscaling with Jsonnet

Mimir Jsonnet supports autoscaling for the following components:

Autoscaling, which is based on Prometheus metrics and Kubernetes-based Event Driven Autoscaler (KEDA), uses Kubernetes’ Horizontal Pod Autoscaler (HPA).

HPA is not configured directly in Jsonnet but it’s created and updated by KEDA. KEDA is an operator, running in the Kubernetes cluster, which is responsible to simplify the setup of HPA with custom metrics (Prometheus in our case).

Warning
Do not use the same Mimir or Grafana Enterprise Metrics cluster for storing and querying autoscaling metrics. Using the same cluster can create a dangerous feedback loop:

Don’t use the same Mimir or Grafana Enterprise Metrics cluster for storing and querying autoscaling metrics. Using the same cluster can create a dangerous feedback loop.

For instance, if the Mimir or GEM cluster becomes unavailable, autoscaling stops working, because it cannot query the metrics. This prevents the cluster from automatically scaling up during high load or recovery. This inability to scale further exacerbates the cluster’s unavailability, which might, in turn, prevent the cluster from recovering.

Instead, use a separate Prometheus instance or a different metrics backend for autoscaling metrics.

How KEDA works

KEDA is a Kubernetes operator aiming to simplify the wiring between HPA and Prometheus.

Kubernetes HPA, out of the box, is not capable of autoscaling based on metrics scraped by Prometheus, but it allows to configure a custom metrics API server which proxies metrics from a data source (e.g. Prometheus) to Kubernetes. Setting up the custom metrics API server for Prometheus in a Kubernetes can be a tedious operation, so KEDA offers an operator to set it up automatically. KEDA supports proxying metrics for a variety of sources, including Prometheus.

KEDA in a nutshell

Runs an operator and an external metrics server.
The metrics server supports proxying for many metric sources, including Prometheus.
The operator watches for ScaledObject custom resource definition (CRD), defining the minimum and maximum replicas, and scaling trigger metrics of a Deployment or StatefulSet, and then configures the related HPA resource. You don’t create the HPA resource in Kubernetes, but the operator creates it for you whenever a ScaledObject CRD is created (and keeps it updated for its whole lifecycle).

Refers to KEDA documentation for more information.

What happens if KEDA is unhealthy

The autoscaling of deployments is always managed by HPA, which is a native Kubernetes feature. KEDA, as we use it, never changes the number of replicas of Mimir Deployments or StatefulSets.

However, if KEDA is not running successfully, there are consequences for Mimir autoscaling too:

keda-operator is down (critical): as the operator is the single point of truth, it will not request the metrics when keda-operator-metrics-apiserver requests them. Changes to ScaledObject CRD will not be reflected to the HPA until the operator is back online. The deployment (e.g. queriers) will keep working but, if there is a surge of traffic, HPA will not be able to detect it due to a lack of metrics and so will not scale up.
keda-operator-metrics-apiserver is down (critical): HPA is not able to fetch updated metrics and it will stop scaling the deployment until metrics will be back. The deployment (e.g. queriers) will keep working but, if there is a surge of traffic, HPA will not be able to detect it due to a lack of metrics and so will not scale up.
keda-admission-webhooks is down (not critical): CRD validation will not be executed. Based on KEDA’s configuration, this can block changes on CRDs until the service is restored. HPA functionality is not affected.

Note
Use a high availability KEDA configuration if autoscaling is critical for your use case.

The alert MimirAutoscalerNotActive fires if HPA is unable to scale the deployment for any reason (e.g. unable to scrape metrics from KEDA metrics API server).

How Kubernetes HPA works

Refer to Kubernetes Horizontal Pod Autoscaling documentation to have a full understanding of how HPA works.

How to enable autoscaling

The following Jsonnet configuration snippet shows an example of how to enable Mimir autoscaling with Jsonnet:

local mimir = import 'mimir/mimir.libsonnet';

mimir {
    _config+:: {
        autoscaling_prometheus_url: 'http://prometheus.default:9090/prometheus',
        // Enable queriers autoscaling.
        autoscaling_querier_enabled: true,
        autoscaling_querier_min_replicas: 10,
        autoscaling_querier_max_replicas: 40,
        // Enable ruler queriers autoscaling.
        autoscaling_ruler_querier_enabled: true,
        autoscaling_ruler_querier_min_replicas: 10,
        autoscaling_ruler_querier_max_replicas: 40,
        // Enable distributor autoscaling.
        autoscaling_distributor_enabled: true,
        autoscaling_distributor_min_replicas: 10,
        autoscaling_distributor_max_replicas: 40,
    }
}

Note
The Mimir Jsonet doesn’t install KEDA.

To install KEDA, follow the instructions in Deploying KEDA.

How to disable autoscaling

There are two options to disable autoscaling in a Mimir cluster:

Set minimum replicas = maximum replicas.
Decommission HPA.

Set minimum replicas = maximum replicas

If KEDA and Kubernetes HPA work correctly but the HPA configuration (metric and threshold) are not giving the expected results (e.g. not scaling up when required), a simple solution to bypass the autoscaling algorithm is to set the minimum and maximum replicas to the same value. (e.g. autoscaling_querier_min_replicas: 40 and autoscaling_querier_max_replicas: 40).

Decommission HPA

To fully decommission HPA in a Mimir cluster you have to:

Disable the relevant autoscaler (e.g. autoscaling_querier_enabled: false).
Manually set the expected number of replicas for the given Mimir component.

The following example shows how to disable querier autoscaler and configure querier Deployment with 10 replicas:

local k = import 'github.com/grafana/jsonnet-libs/ksonnet-util/kausal.libsonnet';
local deployment = k.apps.v1.deployment;

mimir {
    _config+:: {
        autoscaling_querier_enabled: false,
    },

    querier_deployment+: deployment.mixin.spec.withReplicas(10),
}

Migrate from Consul to memberlist KV store for hash rings without downtime

Wed, 03 Jun 2026 09:01:40 +0200

Migrate from Consul to memberlist KV store for hash rings without downtime

Mimir Jsonnet uses memberlist as KV store for hash rings since Mimir 2.2.0.

Memberlist can be disabled by using the following configuration:

{
  _config+:: {
    memberlist_ring_enabled: false
  }
}

If you are running Mimir hash rings with Consul and would like to migrate to memberlist without any downtime, you can follow instructions in this document.

Step 1: Enable memberlist and multi KV store.

{
  _config+:: {
    memberlist_ring_enabled: true,
    multikv_migration_enabled: true,
  }
}

Step 1 configures components to use multi KV store, with consul as primary and memberlist as secondary stores. This step requires rollout of all Mimir components. After applying this step all Mimir components will expose /memberlist page on HTTP admin interface, which can be used to check health of memberlist cluster.

Step 2: Enable KV store mirroring

{
  _config+:: {
    memberlist_ring_enabled: true,
    multikv_migration_enabled: true,
    multikv_mirror_enabled: true,  // Changed in this step.
  }
}

In this step we enable writes to primary KV store (Consul) to be mirrored into secondary store (memberlist). Applying this change will not cause restart of Mimir components.

You can monitor following metrics to check if mirroring was enabled on all components and if it works correctly:

cortex_multikv_mirror_enabled – shows which components have KV store mirroring enabled. All Mimir components should start mirroring to secondary KV store reloading runtime configuration.
rate(cortex_multikv_mirror_writes_total[1m]) – shows rate of writes to secondary KV store in writes per second.
rate(cortex_multikv_mirror_write_errors_total[1m]) – shows rate of write errors to secondary KV store, in errors per second.

After mirroring is enabled, you should see a key for each Mimir hash ring in the Memberlist cluster information admin page. See list of components that use hash ring.

Step 3: Switch Primary and Secondary store

{
  _config+:: {
    memberlist_ring_enabled: true,
    multikv_migration_enabled: true,
    multikv_mirror_enabled: true,
    multikv_switch_primary_secondary: true,  // Changed in this step.
  }
}

This change will switch primary and secondary stores as used by multi KV. From this point on Mimir components will use memberlist as primary KV store, and they will mirror updates to Consul. This step does not require restart of Mimir components.

To see if all components started to use memberlist as primary store, please watch cortex_multikv_primary_store metric.

Step 4: Disable mirroring to Consul

{
  _config+:: {
    memberlist_ring_enabled: true,
    multikv_migration_enabled: true,
    multikv_mirror_enabled: false,  // Changed in this step.
    multikv_switch_primary_secondary: true,
  }
}

This step does not require restart of any Mimir component. After applying the change components will stop writing ring updates to Consul, and will only use memberlist. You can watch cortex_multikv_mirror_enabled metric to see if all components have picked up updated configuration.

Step 5: Disable `multi` KV Store

{
  _config+:: {
    memberlist_ring_enabled: true,
    multikv_migration_enabled: false,  // Changed in this step.
    multikv_mirror_enabled: false,
    multikv_switch_primary_secondary: true,
    multikv_migration_teardown: true,  // Added in this step.
  }
}

This configuration change will cause a new rollout of all components. After the restart components will no longer use multi KV store and will be configured to use memberlist only. We use multikv_migration_teardown to preserve runtime configuration for multi KV store for components that haven’t restarted yet.

All cortex_multikv_* metrics are only exposed by components that use multi KV store. As components restart, these metrics will disappear.

Note
Setting multikv_migration_enabled: false while keeping memberlist_ring_enabled: true removes the Consul workload.

That’s expected, since Consul isn’t used anymore—you disabled mirroring to it in step 4.

If you need to keep consul running, you can explicitly set consul_enabled: true in _config.

Step 6: Cleanup

We have successfully migrated Mimir cluster from using Consul to memberlist without any downtime! As a final step, we can remove all migration-related config options:

multikv_migration_enabled
multikv_mirror_enabled
multikv_switch_primary_secondary
multikv_migration_teardown

Our final memberlist configuration will be:

{
  _config+:: {
    memberlist_ring_enabled: true,
  }
}

This will not trigger new restart of Mimir components. After applying this change, you are finished.

Migrate query-scheduler from DNS-based to ring-based service discovery

Wed, 03 Jun 2026 09:01:40 +0200

Migrate query-scheduler from DNS-based to ring-based service discovery

The query-scheduler supports two service discovery mechanisms:

To migrate the query-scheduler from DNS-based to ring-based service discovery when your Mimir cluster is deployed using Jsonnet:

Configure the query-scheduler instances to join a ring, but keep the querier and query-frontend instances discovering query-schedulers via DNS:
jsonnet
```
{
  _config+:: {
    query_scheduler_service_discovery_mode: 'ring',
    query_scheduler_service_discovery_ring_read_path_enabled: false,
  }
}
```
Wait until query-scheduler changes have been applied.
Open the query-scheduler ring status page and ensure all query-scheduler instances are registered to the ring.

Configure query-frontend and querier instances to discover query-schedulers via the ring:

{
  _config+:: {
    query_scheduler_service_discovery_mode: 'ring',
    query_scheduler_service_discovery_ring_read_path_enabled: true,
  }
}

Deploy Grafana Mimir with Jsonnet and Tanka on Grafana Labs

Deploy Grafana Mimir with Jsonnet and Tanka

Deploy Grafana Mimir with Jsonnet and Tanka

Configure Grafana Mimir to use low resources with Jsonnet

Configure Grafana Mimir to use low resources with Jsonnet

Anti-affinity

Example: disable anti-affinity

Resources

Configure ingest storage architecture

Configure ingest storage architecture

Kafka connection options

Kafka partition sizing

Configure the Grafana Mimir object storage backend with Jsonnet

Configure the Grafana Mimir object storage backend with Jsonnet

Amazon S3 (s3) storage configuration options

Azure (azure) storage configuration options

Google Cloud Storage (gcs) storage configuration options

Configure the Grafana Mimir ruler with Jsonnet

Configure the Grafana Mimir ruler with Jsonnet

Operational modes

Migrate to remote evaluation

Configure Grafana Mimir autoscaling with Jsonnet

Configure Grafana Mimir autoscaling with Jsonnet

How KEDA works

KEDA in a nutshell

What happens if KEDA is unhealthy

How Kubernetes HPA works

How to enable autoscaling

How to disable autoscaling

Set minimum replicas = maximum replicas

Decommission HPA

Migrate from Consul to memberlist KV store for hash rings without downtime

Migrate from Consul to memberlist KV store for hash rings without downtime

Step 1: Enable memberlist and multi KV store.

Step 2: Enable KV store mirroring

Step 3: Switch Primary and Secondary store

Step 4: Disable mirroring to Consul

Step 5: Disable multi KV Store

Step 6: Cleanup

Migrate query-scheduler from DNS-based to ring-based service discovery

Migrate query-scheduler from DNS-based to ring-based service discovery

Amazon S3 (`s3`) storage configuration options

Azure (`azure`) storage configuration options

Google Cloud Storage (`gcs`) storage configuration options

Step 5: Disable `multi` KV Store