Menu

This is documentation for the next version of Loki. For the latest stable release, go to the latest version.

Documentationbreadcrumb arrow Grafana Lokibreadcrumb arrow Set upbreadcrumb arrow Installbreadcrumb arrow Install using Helmbreadcrumb arrow Helm chart values
Open source

Helm Chart Values

This is the generated reference for the Loki Helm Chart values.

Note: This reference is for the Loki Helm chart version 3.0 or greater. If you are using the grafana/loki-stack Helm chart from the community repo, please refer to the values.yaml of the respective Github repository grafana/helm-charts.

KeyTypeDescriptionDefault
adminApiobjectConfiguration for the `admin-api` target
{
  "affinity": {},
  "annotations": {},
  "containerSecurityContext": {
    "allowPrivilegeEscalation": false,
    "capabilities": {
      "drop": [
        "ALL"
      ]
    },
    "readOnlyRootFilesystem": true
  },
  "env": [],
  "extraArgs": {},
  "extraContainers": [],
  "extraEnvFrom": [],
  "extraVolumeMounts": [],
  "extraVolumes": [],
  "hostAliases": [],
  "initContainers": [],
  "labels": {},
  "nodeSelector": {},
  "podSecurityContext": {
    "runAsGroup": 10001,
    "runAsNonRoot": true,
    "runAsUser": 10001
  },
  "readinessProbe": {
    "httpGet": {
      "path": "/ready",
      "port": "http-metrics"
    },
    "initialDelaySeconds": 45
  },
  "replicas": 1,
  "resources": {},
  "service": {
    "annotations": {},
    "labels": {}
  },
  "strategy": {
    "type": "RollingUpdate"
  },
  "terminationGracePeriodSeconds": 60,
  "tolerations": []
}
adminApi.affinityobjectAffinity for admin-api Pods
{}
adminApi.annotationsobjectAdditional annotations for the `admin-api` Deployment
{}
adminApi.envlistConfigure optional environment variables
[]
adminApi.extraArgsobjectAdditional CLI arguments for the `admin-api` target
{}
adminApi.extraContainerslistConifgure optional extraContainers
[]
adminApi.extraEnvFromlistEnvironment variables from secrets or configmaps to add to the admin-api pods
[]
adminApi.extraVolumeMountslistAdditional volume mounts for Pods
[]
adminApi.extraVolumeslistAdditional volumes for Pods
[]
adminApi.hostAliaseslisthostAliases to add
[]
adminApi.initContainerslistConfigure optional initContainers
[]
adminApi.labelsobjectAdditional labels for the `admin-api` Deployment
{}
adminApi.nodeSelectorobjectNode selector for admin-api Pods
{}
adminApi.podSecurityContextobjectRun container as user `enterprise-logs(uid=10001)` `fsGroup` must not be specified, because these security options are applied on container level not on Pod level.
{
  "runAsGroup": 10001,
  "runAsNonRoot": true,
  "runAsUser": 10001
}
adminApi.readinessProbeobjectReadiness probe
{
  "httpGet": {
    "path": "/ready",
    "port": "http-metrics"
  },
  "initialDelaySeconds": 45
}
adminApi.replicasintDefine the amount of instances
1
adminApi.resourcesobjectValues are defined in small.yaml and large.yaml
{}
adminApi.serviceobjectAdditional labels and annotations for the `admin-api` Service
{
  "annotations": {},
  "labels": {}
}
adminApi.strategyobjectUpdate strategy
{
  "type": "RollingUpdate"
}
adminApi.terminationGracePeriodSecondsintGrace period to allow the admin-api to shutdown before it is killed
60
adminApi.tolerationslistTolerations for admin-api Pods
[]
backendobjectConfiguration for the backend pod(s)
{
  "affinity": {
    "podAntiAffinity": {
      "requiredDuringSchedulingIgnoredDuringExecution": [
        {
          "labelSelector": {
            "matchLabels": {
              "app.kubernetes.io/component": "backend"
            }
          },
          "topologyKey": "kubernetes.io/hostname"
        }
      ]
    }
  },
  "annotations": {},
  "autoscaling": {
    "behavior": {},
    "enabled": false,
    "maxReplicas": 6,
    "minReplicas": 3,
    "targetCPUUtilizationPercentage": 60,
    "targetMemoryUtilizationPercentage": null
  },
  "dnsConfig": {},
  "extraArgs": [],
  "extraEnv": [],
  "extraEnvFrom": [],
  "extraVolumeMounts": [],
  "extraVolumes": [],
  "image": {
    "registry": null,
    "repository": null,
    "tag": null
  },
  "initContainers": [],
  "nodeSelector": {},
  "persistence": {
    "annotations": {},
    "dataVolumeParameters": {
      "emptyDir": {}
    },
    "enableStatefulSetAutoDeletePVC": true,
    "selector": null,
    "size": "10Gi",
    "storageClass": null,
    "volumeClaimsEnabled": true
  },
  "podAnnotations": {},
  "podLabels": {},
  "podManagementPolicy": "Parallel",
  "priorityClassName": null,
  "replicas": 3,
  "resources": {},
  "selectorLabels": {},
  "service": {
    "annotations": {},
    "labels": {}
  },
  "targetModule": "backend",
  "terminationGracePeriodSeconds": 300,
  "tolerations": [],
  "topologySpreadConstraints": []
}
backend.affinityobjectAffinity for backend pods.
Hard node anti-affinity
backend.annotationsobjectAnnotations for backend StatefulSet
{}
backend.autoscaling.behaviorobjectBehavior policies while scaling.
{}
backend.autoscaling.enabledboolEnable autoscaling for the backend.
false
backend.autoscaling.maxReplicasintMaximum autoscaling replicas for the backend.
6
backend.autoscaling.minReplicasintMinimum autoscaling replicas for the backend.
3
backend.autoscaling.targetCPUUtilizationPercentageintTarget CPU utilization percentage for the backend.
60
backend.autoscaling.targetMemoryUtilizationPercentagestringTarget memory utilization percentage for the backend.
null
backend.dnsConfigobjectDNS config for backend pods
{}
backend.extraArgslistAdditional CLI args for the backend
[]
backend.extraEnvlistEnvironment variables to add to the backend pods
[]
backend.extraEnvFromlistEnvironment variables from secrets or configmaps to add to the backend pods
[]
backend.extraVolumeMountslistVolume mounts to add to the backend pods
[]
backend.extraVolumeslistVolumes to add to the backend pods
[]
backend.image.registrystringThe Docker registry for the backend image. Overrides `loki.image.registry`
null
backend.image.repositorystringDocker image repository for the backend image. Overrides `loki.image.repository`
null
backend.image.tagstringDocker image tag for the backend image. Overrides `loki.image.tag`
null
backend.initContainerslistInit containers to add to the backend pods
[]
backend.nodeSelectorobjectNode selector for backend pods
{}
backend.persistence.annotationsobjectAnnotations for volume claim
{}
backend.persistence.dataVolumeParametersobjectParameters used for the `data` volume when volumeClaimEnabled if false
{
  "emptyDir": {}
}
backend.persistence.enableStatefulSetAutoDeletePVCboolEnable StatefulSetAutoDeletePVC feature
true
backend.persistence.selectorstringSelector for persistent disk
null
backend.persistence.sizestringSize of persistent disk
"10Gi"
backend.persistence.storageClassstringStorage class to be used. If defined, storageClassName: . If set to "-", storageClassName: "", which disables dynamic provisioning. If empty or set to null, no storageClassName spec is set, choosing the default provisioner (gp2 on AWS, standard on GKE, AWS, and OpenStack).
null
backend.persistence.volumeClaimsEnabledboolEnable volume claims in pod spec
true
backend.podAnnotationsobjectAnnotations for backend pods
{}
backend.podLabelsobjectAdditional labels for each `backend` pod
{}
backend.podManagementPolicystringThe default is to deploy all pods in parallel.
"Parallel"
backend.priorityClassNamestringThe name of the PriorityClass for backend pods
null
backend.replicasintNumber of replicas for the backend
3
backend.resourcesobjectResource requests and limits for the backend
{}
backend.selectorLabelsobjectAdditional selector labels for each `backend` pod
{}
backend.service.annotationsobjectAnnotations for backend Service
{}
backend.service.labelsobjectAdditional labels for backend Service
{}
backend.targetModulestringComma-separated list of Loki modules to load for the backend
"backend"
backend.terminationGracePeriodSecondsintGrace period to allow the backend to shutdown before it is killed. Especially for the ingester, this must be increased. It must be long enough so backends can be gracefully shutdown flushing/transferring all data and to successfully leave the member ring on shutdown.
300
backend.tolerationslistTolerations for backend pods
[]
backend.topologySpreadConstraintslistTopology Spread Constraints for backend pods
[]
bloomBuilderobjectConfiguration for the bloom-builder
{
  "affinity": {
    "podAntiAffinity": {
      "requiredDuringSchedulingIgnoredDuringExecution": [
        {
          "labelSelector": {
            "matchLabels": {
              "app.kubernetes.io/component": "bloom-builder"
            }
          },
          "topologyKey": "kubernetes.io/hostname"
        }
      ]
    }
  },
  "appProtocol": {
    "grpc": ""
  },
  "autoscaling": {
    "behavior": {
      "enabled": false,
      "scaleDown": {},
      "scaleUp": {}
    },
    "customMetrics": [],
    "enabled": false,
    "maxReplicas": 3,
    "minReplicas": 1,
    "targetCPUUtilizationPercentage": 60,
    "targetMemoryUtilizationPercentage": null
  },
  "command": null,
  "extraArgs": [],
  "extraContainers": [],
  "extraEnv": [],
  "extraEnvFrom": [],
  "extraVolumeMounts": [],
  "extraVolumes": [],
  "hostAliases": [],
  "image": {
    "registry": null,
    "repository": null,
    "tag": null
  },
  "maxUnavailable": null,
  "nodeSelector": {},
  "podAnnotations": {},
  "podLabels": {},
  "priorityClassName": null,
  "replicas": 0,
  "resources": {},
  "serviceAnnotations": {},
  "serviceLabels": {},
  "terminationGracePeriodSeconds": 30,
  "tolerations": []
}
bloomBuilder.affinityobjectAffinity for bloom-builder pods.
Hard node anti-affinity
bloomBuilder.appProtocolobjectAdds the appProtocol field to the queryFrontend service. This allows bloomBuilder to work with istio protocol selection.
{
  "grpc": ""
}
bloomBuilder.appProtocol.grpcstringSet the optional grpc service protocol. Ex: "grpc", "http2" or "https"
""
bloomBuilder.autoscaling.behavior.enabledboolEnable autoscaling behaviours
false
bloomBuilder.autoscaling.behavior.scaleDownobjectdefine scale down policies, must conform to HPAScalingRules
{}
bloomBuilder.autoscaling.behavior.scaleUpobjectdefine scale up policies, must conform to HPAScalingRules
{}
bloomBuilder.autoscaling.customMetricslistAllows one to define custom metrics using the HPA/v2 schema (for example, Pods, Object or External metrics)
[]
bloomBuilder.autoscaling.enabledboolEnable autoscaling for the bloom-builder
false
bloomBuilder.autoscaling.maxReplicasintMaximum autoscaling replicas for the bloom-builder
3
bloomBuilder.autoscaling.minReplicasintMinimum autoscaling replicas for the bloom-builder
1
bloomBuilder.autoscaling.targetCPUUtilizationPercentageintTarget CPU utilisation percentage for the bloom-builder
60
bloomBuilder.autoscaling.targetMemoryUtilizationPercentagestringTarget memory utilisation percentage for the bloom-builder
null
bloomBuilder.commandstringCommand to execute instead of defined in Docker image
null
bloomBuilder.extraArgslistAdditional CLI args for the bloom-builder
[]
bloomBuilder.extraContainerslistContainers to add to the bloom-builder pods
[]
bloomBuilder.extraEnvlistEnvironment variables to add to the bloom-builder pods
[]
bloomBuilder.extraEnvFromlistEnvironment variables from secrets or configmaps to add to the bloom-builder pods
[]
bloomBuilder.extraVolumeMountslistVolume mounts to add to the bloom-builder pods
[]
bloomBuilder.extraVolumeslistVolumes to add to the bloom-builder pods
[]
bloomBuilder.hostAliaseslisthostAliases to add
[]
bloomBuilder.image.registrystringThe Docker registry for the bloom-builder image. Overrides `loki.image.registry`
null
bloomBuilder.image.repositorystringDocker image repository for the bloom-builder image. Overrides `loki.image.repository`
null
bloomBuilder.image.tagstringDocker image tag for the bloom-builder image. Overrides `loki.image.tag`
null
bloomBuilder.maxUnavailablestringPod Disruption Budget maxUnavailable
null
bloomBuilder.nodeSelectorobjectNode selector for bloom-builder pods
{}
bloomBuilder.podAnnotationsobjectAnnotations for bloom-builder pods
{}
bloomBuilder.podLabelsobjectLabels for bloom-builder pods
{}
bloomBuilder.priorityClassNamestringThe name of the PriorityClass for bloom-builder pods
null
bloomBuilder.replicasintNumber of replicas for the bloom-builder
0
bloomBuilder.resourcesobjectResource requests and limits for the bloom-builder
{}
bloomBuilder.serviceAnnotationsobjectAnnotations for bloom-builder service
{}
bloomBuilder.serviceLabelsobjectLabels for bloom-builder service
{}
bloomBuilder.terminationGracePeriodSecondsintGrace period to allow the bloom-builder to shutdown before it is killed
30
bloomBuilder.tolerationslistTolerations for bloom-builder pods
[]
bloomGatewayobjectConfiguration for the bloom-gateway
{
  "affinity": {
    "podAntiAffinity": {
      "requiredDuringSchedulingIgnoredDuringExecution": [
        {
          "labelSelector": {
            "matchLabels": {
              "app.kubernetes.io/component": "bloom-gateway"
            }
          },
          "topologyKey": "kubernetes.io/hostname"
        }
      ]
    }
  },
  "appProtocol": {
    "grpc": ""
  },
  "command": null,
  "extraArgs": [],
  "extraContainers": [],
  "extraEnv": [],
  "extraEnvFrom": [],
  "extraVolumeMounts": [],
  "extraVolumes": [],
  "hostAliases": [],
  "image": {
    "registry": null,
    "repository": null,
    "tag": null
  },
  "initContainers": [],
  "livenessProbe": {},
  "nodeSelector": {},
  "persistence": {
    "annotations": {},
    "claims": [
      {
        "name": "data",
        "size": "10Gi",
        "storageClass": null
      }
    ],
    "enableStatefulSetAutoDeletePVC": false,
    "enabled": false,
    "whenDeleted": "Retain",
    "whenScaled": "Retain"
  },
  "podAnnotations": {},
  "podLabels": {},
  "priorityClassName": null,
  "readinessProbe": {},
  "replicas": 0,
  "resources": {},
  "serviceAccount": {
    "annotations": {},
    "automountServiceAccountToken": true,
    "create": false,
    "imagePullSecrets": [],
    "name": null
  },
  "serviceAnnotations": {},
  "serviceLabels": {},
  "terminationGracePeriodSeconds": 30,
  "tolerations": []
}
bloomGateway.affinityobjectAffinity for bloom-gateway pods.
Hard node anti-affinity
bloomGateway.appProtocolobjectSet the optional grpc service protocol. Ex: "grpc", "http2" or "https"
{
  "grpc": ""
}
bloomGateway.commandstringCommand to execute instead of defined in Docker image
null
bloomGateway.extraArgslistAdditional CLI args for the bloom-gateway
[]
bloomGateway.extraContainerslistContainers to add to the bloom-gateway pods
[]
bloomGateway.extraEnvlistEnvironment variables to add to the bloom-gateway pods
[]
bloomGateway.extraEnvFromlistEnvironment variables from secrets or configmaps to add to the bloom-gateway pods
[]
bloomGateway.extraVolumeMountslistVolume mounts to add to the bloom-gateway pods
[]
bloomGateway.extraVolumeslistVolumes to add to the bloom-gateway pods
[]
bloomGateway.hostAliaseslisthostAliases to add
[]
bloomGateway.image.registrystringThe Docker registry for the bloom-gateway image. Overrides `loki.image.registry`
null
bloomGateway.image.repositorystringDocker image repository for the bloom-gateway image. Overrides `loki.image.repository`
null
bloomGateway.image.tagstringDocker image tag for the bloom-gateway image. Overrides `loki.image.tag`
null
bloomGateway.initContainerslistInit containers to add to the bloom-gateway pods
[]
bloomGateway.livenessProbeobjectliveness probe settings for ingester pods. If empty use `loki.livenessProbe`
{}
bloomGateway.nodeSelectorobjectNode selector for bloom-gateway pods
{}
bloomGateway.persistence.annotationsobjectAnnotations for bloom-gateway PVCs
{}
bloomGateway.persistence.claimslistList of the bloom-gateway PVCs

bloomGateway.persistence.claims[0].sizestringSize of persistent disk
"10Gi"
bloomGateway.persistence.enableStatefulSetAutoDeletePVCboolEnable StatefulSetAutoDeletePVC feature
false
bloomGateway.persistence.enabledboolEnable creating PVCs for the bloom-gateway
false
bloomGateway.podAnnotationsobjectAnnotations for bloom-gateway pods
{}
bloomGateway.podLabelsobjectLabels for bloom-gateway pods
{}
bloomGateway.priorityClassNamestringThe name of the PriorityClass for bloom-gateway pods
null
bloomGateway.readinessProbeobjectreadiness probe settings for ingester pods. If empty, use `loki.readinessProbe`
{}
bloomGateway.replicasintNumber of replicas for the bloom-gateway
0
bloomGateway.resourcesobjectResource requests and limits for the bloom-gateway
{}
bloomGateway.serviceAccount.annotationsobjectAnnotations for the bloom-gateway service account
{}
bloomGateway.serviceAccount.automountServiceAccountTokenboolSet this toggle to false to opt out of automounting API credentials for the service account
true
bloomGateway.serviceAccount.imagePullSecretslistImage pull secrets for the bloom-gateway service account
[]
bloomGateway.serviceAccount.namestringThe name of the ServiceAccount to use for the bloom-gateway. If not set and create is true, a name is generated by appending "-bloom-gateway" to the common ServiceAccount.
null
bloomGateway.serviceAnnotationsobjectAnnotations for bloom-gateway service
{}
bloomGateway.serviceLabelsobjectLabels for bloom-gateway service
{}
bloomGateway.terminationGracePeriodSecondsintGrace period to allow the bloom-gateway to shutdown before it is killed
30
bloomGateway.tolerationslistTolerations for bloom-gateway pods
[]
bloomPlannerobjectConfiguration for the bloom-planner
{
  "affinity": {
    "podAntiAffinity": {
      "requiredDuringSchedulingIgnoredDuringExecution": [
        {
          "labelSelector": {
            "matchLabels": {
              "app.kubernetes.io/component": "bloom-planner"
            }
          },
          "topologyKey": "kubernetes.io/hostname"
        }
      ]
    }
  },
  "appProtocol": {
    "grpc": ""
  },
  "command": null,
  "extraArgs": [],
  "extraContainers": [],
  "extraEnv": [],
  "extraEnvFrom": [],
  "extraVolumeMounts": [],
  "extraVolumes": [],
  "hostAliases": [],
  "image": {
    "registry": null,
    "repository": null,
    "tag": null
  },
  "initContainers": [],
  "livenessProbe": {},
  "nodeSelector": {},
  "persistence": {
    "annotations": {},
    "claims": [
      {
        "name": "data",
        "size": "10Gi",
        "storageClass": null
      }
    ],
    "enableStatefulSetAutoDeletePVC": false,
    "enabled": false,
    "whenDeleted": "Retain",
    "whenScaled": "Retain"
  },
  "podAnnotations": {},
  "podLabels": {},
  "priorityClassName": null,
  "readinessProbe": {},
  "replicas": 0,
  "resources": {},
  "serviceAccount": {
    "annotations": {},
    "automountServiceAccountToken": true,
    "create": false,
    "imagePullSecrets": [],
    "name": null
  },
  "serviceAnnotations": {},
  "serviceLabels": {},
  "terminationGracePeriodSeconds": 30,
  "tolerations": []
}
bloomPlanner.affinityobjectAffinity for bloom-planner pods.
Hard node anti-affinity
bloomPlanner.appProtocolobjectSet the optional grpc service protocol. Ex: "grpc", "http2" or "https"
{
  "grpc": ""
}
bloomPlanner.commandstringCommand to execute instead of defined in Docker image
null
bloomPlanner.extraArgslistAdditional CLI args for the bloom-planner
[]
bloomPlanner.extraContainerslistContainers to add to the bloom-planner pods
[]
bloomPlanner.extraEnvlistEnvironment variables to add to the bloom-planner pods
[]
bloomPlanner.extraEnvFromlistEnvironment variables from secrets or configmaps to add to the bloom-planner pods
[]
bloomPlanner.extraVolumeMountslistVolume mounts to add to the bloom-planner pods
[]
bloomPlanner.extraVolumeslistVolumes to add to the bloom-planner pods
[]
bloomPlanner.hostAliaseslisthostAliases to add
[]
bloomPlanner.image.registrystringThe Docker registry for the bloom-planner image. Overrides `loki.image.registry`
null
bloomPlanner.image.repositorystringDocker image repository for the bloom-planner image. Overrides `loki.image.repository`
null
bloomPlanner.image.tagstringDocker image tag for the bloom-planner image. Overrides `loki.image.tag`
null
bloomPlanner.initContainerslistInit containers to add to the bloom-planner pods
[]
bloomPlanner.livenessProbeobjectliveness probe settings for ingester pods. If empty use `loki.livenessProbe`
{}
bloomPlanner.nodeSelectorobjectNode selector for bloom-planner pods
{}
bloomPlanner.persistence.annotationsobjectAnnotations for bloom-planner PVCs
{}
bloomPlanner.persistence.claimslistList of the bloom-planner PVCs

bloomPlanner.persistence.claims[0].sizestringSize of persistent disk
"10Gi"
bloomPlanner.persistence.enableStatefulSetAutoDeletePVCboolEnable StatefulSetAutoDeletePVC feature
false
bloomPlanner.persistence.enabledboolEnable creating PVCs for the bloom-planner
false
bloomPlanner.podAnnotationsobjectAnnotations for bloom-planner pods
{}
bloomPlanner.podLabelsobjectLabels for bloom-planner pods
{}
bloomPlanner.priorityClassNamestringThe name of the PriorityClass for bloom-planner pods
null
bloomPlanner.readinessProbeobjectreadiness probe settings for ingester pods. If empty, use `loki.readinessProbe`
{}
bloomPlanner.replicasintNumber of replicas for the bloom-planner
0
bloomPlanner.resourcesobjectResource requests and limits for the bloom-planner
{}
bloomPlanner.serviceAccount.annotationsobjectAnnotations for the bloom-planner service account
{}
bloomPlanner.serviceAccount.automountServiceAccountTokenboolSet this toggle to false to opt out of automounting API credentials for the service account
true
bloomPlanner.serviceAccount.imagePullSecretslistImage pull secrets for the bloom-planner service account
[]
bloomPlanner.serviceAccount.namestringThe name of the ServiceAccount to use for the bloom-planner. If not set and create is true, a name is generated by appending "-bloom-planner" to the common ServiceAccount.
null
bloomPlanner.serviceAnnotationsobjectAnnotations for bloom-planner service
{}
bloomPlanner.serviceLabelsobjectLabels for bloom-planner service
{}
bloomPlanner.terminationGracePeriodSecondsintGrace period to allow the bloom-planner to shutdown before it is killed
30
bloomPlanner.tolerationslistTolerations for bloom-planner pods
[]
chunksCache.affinityobjectAffinity for chunks-cache pods
{}
chunksCache.allocatedMemoryintAmount of memory allocated to chunks-cache for object storage (in MB).
8192
chunksCache.annotationsobjectAnnotations for the chunks-cache pods
{}
chunksCache.batchSizeintBatchsize for sending and receiving chunks from chunks cache
4
chunksCache.connectionLimitintMaximum number of connections allowed
16384
chunksCache.defaultValiditystringSpecify how long cached chunks should be stored in the chunks-cache before being expired
"0s"
chunksCache.enabledboolSpecifies whether memcached based chunks-cache should be enabled
true
chunksCache.extraArgsobjectAdditional CLI args for chunks-cache
{}
chunksCache.extraContainerslistAdditional containers to be added to the chunks-cache pod.
[]
chunksCache.extraExtendedOptionsstringAdd extended options for chunks-cache memcached container. The format is the same as for the memcached -o/--extend flag. Example: extraExtendedOptions: 'tls,no_hashexpand'
""
chunksCache.extraVolumeMountslistAdditional volume mounts to be added to the chunks-cache pod (applies to both memcached and exporter containers). Example: extraVolumeMounts: - name: extra-volume mountPath: /etc/extra-volume readOnly: true
[]
chunksCache.extraVolumeslistAdditional volumes to be added to the chunks-cache pod (applies to both memcached and exporter containers). Example: extraVolumes: - name: extra-volume secret: secretName: extra-volume-secret
[]
chunksCache.initContainerslistExtra init containers for chunks-cache pods
[]
chunksCache.maxItemMemoryintMaximum item memory for chunks-cache (in MB).
5
chunksCache.nodeSelectorobjectNode selector for chunks-cache pods
{}
chunksCache.parallelismintParallel threads for sending and receiving chunks from chunks cache
5
chunksCache.persistenceobjectPersistence settings for the chunks-cache
{
  "enabled": false,
  "mountPath": "/data",
  "storageClass": null,
  "storageSize": "10G"
}
chunksCache.persistence.enabledboolEnable creating PVCs for the chunks-cache
false
chunksCache.persistence.mountPathstringVolume mount path
"/data"
chunksCache.persistence.storageClassstringStorage class to be used. If defined, storageClassName: . If set to "-", storageClassName: "", which disables dynamic provisioning. If empty or set to null, no storageClassName spec is set, choosing the default provisioner (gp2 on AWS, standard on GKE, AWS, and OpenStack).
null
chunksCache.persistence.storageSizestringSize of persistent disk, must be in G or Gi
"10G"
chunksCache.podAnnotationsobjectAnnotations for chunks-cache pods
{}
chunksCache.podDisruptionBudgetobjectPod Disruption Budget
{
  "maxUnavailable": 1
}
chunksCache.podLabelsobjectLabels for chunks-cache pods
{}
chunksCache.podManagementPolicystringManagement policy for chunks-cache pods
"Parallel"
chunksCache.portintPort of the chunks-cache service
11211
chunksCache.priorityClassNamestringThe name of the PriorityClass for chunks-cache pods
null
chunksCache.replicasintTotal number of chunks-cache replicas
1
chunksCache.resourcesstringResource requests and limits for the chunks-cache By default a safe memory limit will be requested based on allocatedMemory value (floor (* 1.2 allocatedMemory)).
null
chunksCache.serviceobjectService annotations and labels
{
  "annotations": {},
  "labels": {}
}
chunksCache.statefulStrategyobjectStateful chunks-cache strategy
{
  "type": "RollingUpdate"
}
chunksCache.terminationGracePeriodSecondsintGrace period to allow the chunks-cache to shutdown before it is killed
60
chunksCache.timeoutstringMemcached operation timeout
"2000ms"
chunksCache.tolerationslistTolerations for chunks-cache pods
[]
chunksCache.topologySpreadConstraintslisttopologySpreadConstraints allows to customize the default topologySpreadConstraints. This can be either a single dict as shown below or a slice of topologySpreadConstraints. labelSelector is taken from the constraint itself (if it exists) or is generated by the chart using the same selectors as for services.
[]
chunksCache.writebackBufferintMax number of objects to use for cache write back
500000
chunksCache.writebackParallelismintNumber of parallel threads for cache write back
1
chunksCache.writebackSizeLimitstringMax memory to use for cache write back
"500MB"
clusterLabelOverridestringOverrides the chart's cluster label
null
compactorobjectConfiguration for the compactor
{
  "affinity": {
    "podAntiAffinity": {
      "requiredDuringSchedulingIgnoredDuringExecution": [
        {
          "labelSelector": {
            "matchLabels": {
              "app.kubernetes.io/component": "compactor"
            }
          },
          "topologyKey": "kubernetes.io/hostname"
        }
      ]
    }
  },
  "appProtocol": {
    "grpc": ""
  },
  "command": null,
  "extraArgs": [],
  "extraContainers": [],
  "extraEnv": [],
  "extraEnvFrom": [],
  "extraVolumeMounts": [],
  "extraVolumes": [],
  "hostAliases": [],
  "image": {
    "registry": null,
    "repository": null,
    "tag": null
  },
  "initContainers": [],
  "livenessProbe": {},
  "nodeSelector": {},
  "persistence": {
    "annotations": {},
    "claims": [
      {
        "name": "data",
        "size": "10Gi",
        "storageClass": null
      }
    ],
    "enableStatefulSetAutoDeletePVC": false,
    "enabled": false,
    "size": "10Gi",
    "storageClass": null,
    "whenDeleted": "Retain",
    "whenScaled": "Retain"
  },
  "podAnnotations": {},
  "podLabels": {},
  "priorityClassName": null,
  "readinessProbe": {},
  "replicas": 0,
  "resources": {},
  "serviceAccount": {
    "annotations": {},
    "automountServiceAccountToken": true,
    "create": false,
    "imagePullSecrets": [],
    "name": null
  },
  "serviceAnnotations": {},
  "serviceLabels": {},
  "terminationGracePeriodSeconds": 30,
  "tolerations": []
}
compactor.affinityobjectAffinity for compactor pods.
Hard node anti-affinity
compactor.appProtocolobjectSet the optional grpc service protocol. Ex: "grpc", "http2" or "https"
{
  "grpc": ""
}
compactor.commandstringCommand to execute instead of defined in Docker image
null
compactor.extraArgslistAdditional CLI args for the compactor
[]
compactor.extraContainerslistContainers to add to the compactor pods
[]
compactor.extraEnvlistEnvironment variables to add to the compactor pods
[]
compactor.extraEnvFromlistEnvironment variables from secrets or configmaps to add to the compactor pods
[]
compactor.extraVolumeMountslistVolume mounts to add to the compactor pods
[]
compactor.extraVolumeslistVolumes to add to the compactor pods
[]
compactor.hostAliaseslisthostAliases to add
[]
compactor.image.registrystringThe Docker registry for the compactor image. Overrides `loki.image.registry`
null
compactor.image.repositorystringDocker image repository for the compactor image. Overrides `loki.image.repository`
null
compactor.image.tagstringDocker image tag for the compactor image. Overrides `loki.image.tag`
null
compactor.initContainerslistInit containers to add to the compactor pods
[]
compactor.livenessProbeobjectliveness probe settings for ingester pods. If empty use `loki.livenessProbe`
{}
compactor.nodeSelectorobjectNode selector for compactor pods
{}
compactor.persistence.annotationsobjectAnnotations for compactor PVCs
{}
compactor.persistence.claimslistList of the compactor PVCs

compactor.persistence.enableStatefulSetAutoDeletePVCboolEnable StatefulSetAutoDeletePVC feature
false
compactor.persistence.enabledboolEnable creating PVCs for the compactor
false
compactor.persistence.sizestringSize of persistent disk
"10Gi"
compactor.persistence.storageClassstringStorage class to be used. If defined, storageClassName: . If set to "-", storageClassName: "", which disables dynamic provisioning. If empty or set to null, no storageClassName spec is set, choosing the default provisioner (gp2 on AWS, standard on GKE, AWS, and OpenStack).
null
compactor.podAnnotationsobjectAnnotations for compactor pods
{}
compactor.podLabelsobjectLabels for compactor pods
{}
compactor.priorityClassNamestringThe name of the PriorityClass for compactor pods
null
compactor.readinessProbeobjectreadiness probe settings for ingester pods. If empty, use `loki.readinessProbe`
{}
compactor.replicasintNumber of replicas for the compactor
0
compactor.resourcesobjectResource requests and limits for the compactor
{}
compactor.serviceAccount.annotationsobjectAnnotations for the compactor service account
{}
compactor.serviceAccount.automountServiceAccountTokenboolSet this toggle to false to opt out of automounting API credentials for the service account
true
compactor.serviceAccount.imagePullSecretslistImage pull secrets for the compactor service account
[]
compactor.serviceAccount.namestringThe name of the ServiceAccount to use for the compactor. If not set and create is true, a name is generated by appending "-compactor" to the common ServiceAccount.
null
compactor.serviceAnnotationsobjectAnnotations for compactor service
{}
compactor.serviceLabelsobjectLabels for compactor service
{}
compactor.terminationGracePeriodSecondsintGrace period to allow the compactor to shutdown before it is killed
30
compactor.tolerationslistTolerations for compactor pods
[]
deploymentModestringDeployment mode lets you specify how to deploy Loki. There are 3 options: - SingleBinary: Loki is deployed as a single binary, useful for small installs typically without HA, up to a few tens of GB/day. - SimpleScalable: Loki is deployed as 3 targets: read, write, and backend. Useful for medium installs easier to manage than distributed, up to a about 1TB/day. - Distributed: Loki is deployed as individual microservices. The most complicated but most capable, useful for large installs, typically over 1TB/day. There are also 2 additional modes used for migrating between deployment modes: - SingleBinary<->SimpleScalable: Migrate from SingleBinary to SimpleScalable (or vice versa) - SimpleScalable<->Distributed: Migrate from SimpleScalable to Distributed (or vice versa) Note: SimpleScalable and Distributed REQUIRE the use of object storage.
"SimpleScalable"
distributorobjectConfiguration for the distributor
{
  "affinity": {
    "podAntiAffinity": {
      "requiredDuringSchedulingIgnoredDuringExecution": [
        {
          "labelSelector": {
            "matchLabels": {
              "app.kubernetes.io/component": "distributor"
            }
          },
          "topologyKey": "kubernetes.io/hostname"
        }
      ]
    }
  },
  "appProtocol": {
    "grpc": ""
  },
  "autoscaling": {
    "behavior": {
      "enabled": false,
      "scaleDown": {},
      "scaleUp": {}
    },
    "customMetrics": [],
    "enabled": false,
    "maxReplicas": 3,
    "minReplicas": 1,
    "targetCPUUtilizationPercentage": 60,
    "targetMemoryUtilizationPercentage": null
  },
  "command": null,
  "extraArgs": [],
  "extraContainers": [],
  "extraEnv": [],
  "extraEnvFrom": [],
  "extraVolumeMounts": [],
  "extraVolumes": [],
  "hostAliases": [],
  "image": {
    "registry": null,
    "repository": null,
    "tag": null
  },
  "maxSurge": 0,
  "maxUnavailable": null,
  "nodeSelector": {},
  "podAnnotations": {},
  "podLabels": {},
  "priorityClassName": null,
  "replicas": 0,
  "resources": {},
  "serviceAnnotations": {},
  "serviceLabels": {},
  "terminationGracePeriodSeconds": 30,
  "tolerations": []
}
distributor.affinityobjectAffinity for distributor pods.
Hard node anti-affinity
distributor.appProtocolobjectAdds the appProtocol field to the distributor service. This allows distributor to work with istio protocol selection.
{
  "grpc": ""
}
distributor.appProtocol.grpcstringSet the optional grpc service protocol. Ex: "grpc", "http2" or "https"
""
distributor.autoscaling.behavior.enabledboolEnable autoscaling behaviours
false
distributor.autoscaling.behavior.scaleDownobjectdefine scale down policies, must conform to HPAScalingRules
{}
distributor.autoscaling.behavior.scaleUpobjectdefine scale up policies, must conform to HPAScalingRules
{}
distributor.autoscaling.customMetricslistAllows one to define custom metrics using the HPA/v2 schema (for example, Pods, Object or External metrics)
[]
distributor.autoscaling.enabledboolEnable autoscaling for the distributor
false
distributor.autoscaling.maxReplicasintMaximum autoscaling replicas for the distributor
3
distributor.autoscaling.minReplicasintMinimum autoscaling replicas for the distributor
1
distributor.autoscaling.targetCPUUtilizationPercentageintTarget CPU utilisation percentage for the distributor
60
distributor.autoscaling.targetMemoryUtilizationPercentagestringTarget memory utilisation percentage for the distributor
null
distributor.commandstringCommand to execute instead of defined in Docker image
null
distributor.extraArgslistAdditional CLI args for the distributor
[]
distributor.extraContainerslistContainers to add to the distributor pods
[]
distributor.extraEnvlistEnvironment variables to add to the distributor pods
[]
distributor.extraEnvFromlistEnvironment variables from secrets or configmaps to add to the distributor pods
[]
distributor.extraVolumeMountslistVolume mounts to add to the distributor pods
[]
distributor.extraVolumeslistVolumes to add to the distributor pods
[]
distributor.hostAliaseslisthostAliases to add
[]
distributor.image.registrystringThe Docker registry for the distributor image. Overrides `loki.image.registry`
null
distributor.image.repositorystringDocker image repository for the distributor image. Overrides `loki.image.repository`
null
distributor.image.tagstringDocker image tag for the distributor image. Overrides `loki.image.tag`
null
distributor.maxSurgeintMax Surge for distributor pods
0
distributor.maxUnavailablestringPod Disruption Budget maxUnavailable
null
distributor.nodeSelectorobjectNode selector for distributor pods
{}
distributor.podAnnotationsobjectAnnotations for distributor pods
{}
distributor.podLabelsobjectLabels for distributor pods
{}
distributor.priorityClassNamestringThe name of the PriorityClass for distributor pods
null
distributor.replicasintNumber of replicas for the distributor
0
distributor.resourcesobjectResource requests and limits for the distributor
{}
distributor.serviceAnnotationsobjectAnnotations for distributor service
{}
distributor.serviceLabelsobjectLabels for distributor service
{}
distributor.terminationGracePeriodSecondsintGrace period to allow the distributor to shutdown before it is killed
30
distributor.tolerationslistTolerations for distributor pods
[]
enterpriseobjectConfiguration for running Enterprise Loki
{
  "adminApi": {
    "enabled": true
  },
  "adminToken": {
    "additionalNamespaces": [],
    "secret": null
  },
  "canarySecret": null,
  "cluster_name": null,
  "config": "{{- if .Values.enterprise.adminApi.enabled }}\nadmin_client:\n  {{ include \"enterprise-logs.adminAPIStorageConfig\" . | nindent 2 }}\n{{ end }}\nauth:\n  type: {{ .Values.enterprise.adminApi.enabled | ternary \"enterprise\" \"trust\" }}\nauth_enabled: {{ .Values.loki.auth_enabled }}\ncluster_name: {{ include \"loki.clusterName\" . }}\nlicense:\n  path: /etc/loki/license/license.jwt\n",
  "enabled": false,
  "externalConfigName": "",
  "externalLicenseName": null,
  "gelGateway": true,
  "image": {
    "digest": null,
    "pullPolicy": "IfNotPresent",
    "registry": "docker.io",
    "repository": "grafana/enterprise-logs",
    "tag": null
  },
  "license": {
    "contents": "NOTAVALIDLICENSE"
  },
  "provisioner": {
    "additionalTenants": [],
    "affinity": {},
    "annotations": {},
    "enabled": true,
    "env": [],
    "extraVolumeMounts": [],
    "image": {
      "digest": null,
      "pullPolicy": "IfNotPresent",
      "registry": "docker.io",
      "repository": "grafana/enterprise-logs-provisioner",
      "tag": null
    },
    "labels": {},
    "nodeSelector": {},
    "priorityClassName": null,
    "provisionedSecretPrefix": null,
    "securityContext": {
      "fsGroup": 10001,
      "runAsGroup": 10001,
      "runAsNonRoot": true,
      "runAsUser": 10001
    },
    "tolerations": []
  },
  "tokengen": {
    "affinity": {},
    "annotations": {},
    "enabled": true,
    "env": [],
    "extraArgs": [],
    "extraEnvFrom": [],
    "extraVolumeMounts": [],
    "extraVolumes": [],
    "labels": {},
    "nodeSelector": {},
    "priorityClassName": "",
    "securityContext": {
      "fsGroup": 10001,
      "runAsGroup": 10001,
      "runAsNonRoot": true,
      "runAsUser": 10001
    },
    "targetModule": "tokengen",
    "tolerations": []
  },
  "useExternalLicense": false,
  "version": "3.1.1"
}
enterprise.adminApiobjectIf enabled, the correct admin_client storage will be configured. If disabled while running enterprise, make sure auth is set to `type: trust`, or that `auth_enabled` is set to `false`.
{
  "enabled": true
}
enterprise.adminToken.additionalNamespaceslistAdditional namespace to also create the token in. Useful if your Grafana instance is in a different namespace
[]
enterprise.adminToken.secretstringAlternative name for admin token secret, needed by tokengen and provisioner jobs
null
enterprise.canarySecretstringAlternative name of the secret to store token for the canary
null
enterprise.cluster_namestringOptional name of the GEL cluster, otherwise will use .Release.Name The cluster name must match what is in your GEL license
null
enterprise.externalConfigNamestringName of the external config secret to use
""
enterprise.externalLicenseNamestringName of external license secret to use
null
enterprise.gelGatewayboolUse GEL gateway, if false will use the default nginx gateway
true
enterprise.image.digeststringOverrides the image tag with an image digest
null
enterprise.image.pullPolicystringDocker image pull policy
"IfNotPresent"
enterprise.image.registrystringThe Docker registry
"docker.io"
enterprise.image.repositorystringDocker image repository
"grafana/enterprise-logs"
enterprise.image.tagstringDocker image tag
null
enterprise.licenseobjectGrafana Enterprise Logs license In order to use Grafana Enterprise Logs features, you will need to provide the contents of your Grafana Enterprise Logs license, either by providing the contents of the license.jwt, or the name Kubernetes Secret that contains your license.jwt. To set the license contents, use the flag `--set-file 'enterprise.license.contents=./license.jwt'`
{
  "contents": "NOTAVALIDLICENSE"
}
enterprise.provisionerobjectConfiguration for `provisioner` target
{
  "additionalTenants": [],
  "affinity": {},
  "annotations": {},
  "enabled": true,
  "env": [],
  "extraVolumeMounts": [],
  "image": {
    "digest": null,
    "pullPolicy": "IfNotPresent",
    "registry": "docker.io",
    "repository": "grafana/enterprise-logs-provisioner",
    "tag": null
  },
  "labels": {},
  "nodeSelector": {},
  "priorityClassName": null,
  "provisionedSecretPrefix": null,
  "securityContext": {
    "fsGroup": 10001,
    "runAsGroup": 10001,
    "runAsNonRoot": true,
    "runAsUser": 10001
  },
  "tolerations": []
}
enterprise.provisioner.additionalTenantslistAdditional tenants to be created. Each tenant will get a read and write policy and associated token. Tenant must have a name and a namespace for the secret containting the token to be created in. For example additionalTenants: - name: loki secretNamespace: grafana
[]
enterprise.provisioner.affinityobjectAffinity for tokengen Pods
{}
enterprise.provisioner.annotationsobjectAdditional annotations for the `provisioner` Job
{}
enterprise.provisioner.enabledboolWhether the job should be part of the deployment
true
enterprise.provisioner.envlistAdditional Kubernetes environment
[]
enterprise.provisioner.extraVolumeMountslistVolume mounts to add to the provisioner pods
[]
enterprise.provisioner.imageobjectProvisioner image to Utilize
{
  "digest": null,
  "pullPolicy": "IfNotPresent",
  "registry": "docker.io",
  "repository": "grafana/enterprise-logs-provisioner",
  "tag": null
}
enterprise.provisioner.image.digeststringOverrides the image tag with an image digest
null
enterprise.provisioner.image.pullPolicystringDocker image pull policy
"IfNotPresent"
enterprise.provisioner.image.registrystringThe Docker registry
"docker.io"
enterprise.provisioner.image.repositorystringDocker image repository
"grafana/enterprise-logs-provisioner"
enterprise.provisioner.image.tagstringOverrides the image tag whose default is the chart's appVersion
null
enterprise.provisioner.labelsobjectAdditional labels for the `provisioner` Job
{}
enterprise.provisioner.nodeSelectorobjectNode selector for tokengen Pods
{}
enterprise.provisioner.priorityClassNamestringThe name of the PriorityClass for provisioner Job
null
enterprise.provisioner.provisionedSecretPrefixstringName of the secret to store provisioned tokens in
null
enterprise.provisioner.securityContextobjectRun containers as user `enterprise-logs(uid=10001)`
{
  "fsGroup": 10001,
  "runAsGroup": 10001,
  "runAsNonRoot": true,
  "runAsUser": 10001
}
enterprise.provisioner.tolerationslistTolerations for tokengen Pods
[]
enterprise.tokengenobjectConfiguration for `tokengen` target
{
  "affinity": {},
  "annotations": {},
  "enabled": true,
  "env": [],
  "extraArgs": [],
  "extraEnvFrom": [],
  "extraVolumeMounts": [],
  "extraVolumes": [],
  "labels": {},
  "nodeSelector": {},
  "priorityClassName": "",
  "securityContext": {
    "fsGroup": 10001,
    "runAsGroup": 10001,
    "runAsNonRoot": true,
    "runAsUser": 10001
  },
  "targetModule": "tokengen",
  "tolerations": []
}
enterprise.tokengen.affinityobjectAffinity for tokengen Pods
{}
enterprise.tokengen.annotationsobjectAdditional annotations for the `tokengen` Job
{}
enterprise.tokengen.enabledboolWhether the job should be part of the deployment
true
enterprise.tokengen.envlistAdditional Kubernetes environment
[]
enterprise.tokengen.extraArgslistAdditional CLI arguments for the `tokengen` target
[]
enterprise.tokengen.extraEnvFromlistEnvironment variables from secrets or configmaps to add to the tokengen pods
[]
enterprise.tokengen.extraVolumeMountslistAdditional volume mounts for Pods
[]
enterprise.tokengen.extraVolumeslistAdditional volumes for Pods
[]
enterprise.tokengen.labelsobjectAdditional labels for the `tokengen` Job
{}
enterprise.tokengen.nodeSelectorobjectNode selector for tokengen Pods
{}
enterprise.tokengen.priorityClassNamestringThe name of the PriorityClass for tokengen Pods
""
enterprise.tokengen.securityContextobjectRun containers as user `enterprise-logs(uid=10001)`
{
  "fsGroup": 10001,
  "runAsGroup": 10001,
  "runAsNonRoot": true,
  "runAsUser": 10001
}
enterprise.tokengen.targetModulestringComma-separated list of Loki modules to load for tokengen
"tokengen"
enterprise.tokengen.tolerationslistTolerations for tokengen Job
[]
enterprise.useExternalLicenseboolSet to true when providing an external license
false
enterpriseGatewayobjectIf running enterprise and using the default enterprise gateway, configs go here.
{
  "affinity": {},
  "annotations": {},
  "containerSecurityContext": {
    "allowPrivilegeEscalation": false,
    "capabilities": {
      "drop": [
        "ALL"
      ]
    },
    "readOnlyRootFilesystem": true
  },
  "env": [],
  "extraArgs": {},
  "extraContainers": [],
  "extraEnvFrom": [],
  "extraVolumeMounts": [],
  "extraVolumes": [],
  "hostAliases": [],
  "initContainers": [],
  "labels": {},
  "nodeSelector": {},
  "podSecurityContext": {
    "fsGroup": 10001,
    "runAsGroup": 10001,
    "runAsNonRoot": true,
    "runAsUser": 10001
  },
  "readinessProbe": {
    "httpGet": {
      "path": "/ready",
      "port": "http-metrics"
    },
    "initialDelaySeconds": 45
  },
  "replicas": 1,
  "resources": {},
  "service": {
    "annotations": {},
    "labels": {},
    "type": "ClusterIP"
  },
  "strategy": {
    "type": "RollingUpdate"
  },
  "terminationGracePeriodSeconds": 60,
  "tolerations": [],
  "useDefaultProxyURLs": true
}
enterpriseGateway.affinityobjectAffinity for gateway Pods
{}
enterpriseGateway.annotationsobjectAdditional annotations for the `gateway` Pod
{}
enterpriseGateway.envlistConfigure optional environment variables
[]
enterpriseGateway.extraArgsobjectAdditional CLI arguments for the `gateway` target
{}
enterpriseGateway.extraContainerslistConifgure optional extraContainers
[]
enterpriseGateway.extraEnvFromlistEnvironment variables from secrets or configmaps to add to the enterprise gateway pods
[]
enterpriseGateway.extraVolumeMountslistAdditional volume mounts for Pods
[]
enterpriseGateway.extraVolumeslistAdditional volumes for Pods
[]
enterpriseGateway.hostAliaseslisthostAliases to add
[]
enterpriseGateway.initContainerslistConfigure optional initContainers
[]
enterpriseGateway.labelsobjectAdditional labels for the `gateway` Pod
{}
enterpriseGateway.nodeSelectorobjectNode selector for gateway Pods
{}
enterpriseGateway.podSecurityContextobjectRun container as user `enterprise-logs(uid=10001)`
{
  "fsGroup": 10001,
  "runAsGroup": 10001,
  "runAsNonRoot": true,
  "runAsUser": 10001
}
enterpriseGateway.readinessProbeobjectReadiness probe
{
  "httpGet": {
    "path": "/ready",
    "port": "http-metrics"
  },
  "initialDelaySeconds": 45
}
enterpriseGateway.replicasintDefine the amount of instances
1
enterpriseGateway.resourcesobjectValues are defined in small.yaml and large.yaml
{}
enterpriseGateway.serviceobjectService overriding service type
{
  "annotations": {},
  "labels": {},
  "type": "ClusterIP"
}
enterpriseGateway.strategyobjectupdate strategy
{
  "type": "RollingUpdate"
}
enterpriseGateway.terminationGracePeriodSecondsintGrace period to allow the gateway to shutdown before it is killed
60
enterpriseGateway.tolerationslistTolerations for gateway Pods
[]
enterpriseGateway.useDefaultProxyURLsboolIf you want to use your own proxy URLs, set this to false.
true
extraObjectslist
[]
fullnameOverridestringOverrides the chart's computed fullname
null
gateway.affinityobjectAffinity for gateway pods.
Hard node anti-affinity
gateway.annotationsobjectAnnotations for gateway deployment
{}
gateway.autoscaling.behaviorobjectBehavior policies while scaling.
{}
gateway.autoscaling.enabledboolEnable autoscaling for the gateway
false
gateway.autoscaling.maxReplicasintMaximum autoscaling replicas for the gateway
3
gateway.autoscaling.minReplicasintMinimum autoscaling replicas for the gateway
1
gateway.autoscaling.targetCPUUtilizationPercentageintTarget CPU utilisation percentage for the gateway
60
gateway.autoscaling.targetMemoryUtilizationPercentagestringTarget memory utilisation percentage for the gateway
null
gateway.basicAuth.enabledboolEnables basic authentication for the gateway
false
gateway.basicAuth.existingSecretstringExisting basic auth secret to use. Must contain '.htpasswd'
null
gateway.basicAuth.htpasswdstringUses the specified users from the `loki.tenants` list to create the htpasswd file. if `loki.tenants` is not set, the `gateway.basicAuth.username` and `gateway.basicAuth.password` are used. The value is templated using `tpl`. Override this to use a custom htpasswd, e.g. in case the default causes high CPU load.
Either `loki.tenants` or `gateway.basicAuth.username` and `gateway.basicAuth.password`.
gateway.basicAuth.passwordstringThe basic auth password for the gateway
null
gateway.basicAuth.usernamestringThe basic auth username for the gateway
null
gateway.containerPortintDefault container port
8080
gateway.containerSecurityContextobjectThe SecurityContext for gateway containers
{
  "allowPrivilegeEscalation": false,
  "capabilities": {
    "drop": [
      "ALL"
    ]
  },
  "readOnlyRootFilesystem": true
}
gateway.deploymentStrategy.typestring
"RollingUpdate"
gateway.dnsConfigobjectDNS config for gateway pods
{}
gateway.enabledboolSpecifies whether the gateway should be enabled
true
gateway.extraArgslistAdditional CLI args for the gateway
[]
gateway.extraContainerslistContainers to add to the gateway pods
[]
gateway.extraEnvlistEnvironment variables to add to the gateway pods
[]
gateway.extraEnvFromlistEnvironment variables from secrets or configmaps to add to the gateway pods
[]
gateway.extraVolumeMountslistVolume mounts to add to the gateway pods
[]
gateway.extraVolumeslistVolumes to add to the gateway pods
[]
gateway.image.digeststringOverrides the gateway image tag with an image digest
null
gateway.image.pullPolicystringThe gateway image pull policy
"IfNotPresent"
gateway.image.registrystringThe Docker registry for the gateway image
"docker.io"
gateway.image.repositorystringThe gateway image repository
"nginxinc/nginx-unprivileged"
gateway.image.tagstringThe gateway image tag
"1.27-alpine"
gateway.ingress.annotationsobjectAnnotations for the gateway ingress
{}
gateway.ingress.enabledboolSpecifies whether an ingress for the gateway should be created
false
gateway.ingress.hostslistHosts configuration for the gateway ingress, passed through the `tpl` function to allow templating
[
  {
    "host": "gateway.loki.example.com",
    "paths": [
      {
        "path": "/"
      }
    ]
  }
]
gateway.ingress.ingressClassNamestringIngress Class Name. MAY be required for Kubernetes versions >= 1.18
""
gateway.ingress.labelsobjectLabels for the gateway ingress
{}
gateway.ingress.tlslistTLS configuration for the gateway ingress. Hosts passed through the `tpl` function to allow templating
[
  {
    "hosts": [
      "gateway.loki.example.com"
    ],
    "secretName": "loki-gateway-tls"
  }
]
gateway.lifecycleobjectLifecycle for the gateway container
{}
gateway.nginxConfig.clientMaxBodySizestringAllows customizing the `client_max_body_size` directive
"4M"
gateway.nginxConfig.customBackendUrlstringOverride Backend URL
null
gateway.nginxConfig.customReadUrlstringOverride Read URL
null
gateway.nginxConfig.customWriteUrlstringOverride Write URL
null
gateway.nginxConfig.enableIPv6boolEnable listener for IPv6, disable on IPv4-only systems
true
gateway.nginxConfig.filestringConfig file contents for Nginx. Passed through the `tpl` function to allow templating
See values.yaml
gateway.nginxConfig.httpSnippetstringAllows appending custom configuration to the http block, passed through the `tpl` function to allow templating
"{{ if .Values.loki.tenants }}proxy_set_header X-Scope-OrgID $remote_user;{{ end }}"
gateway.nginxConfig.logFormatstringNGINX log format
"main '$remote_addr - $remote_user [$time_local]  $status '\n        '\"$request\" $body_bytes_sent \"$http_referer\" '\n        '\"$http_user_agent\" \"$http_x_forwarded_for\"';"
gateway.nginxConfig.resolverstringAllows overriding the DNS resolver address nginx will use.
""
gateway.nginxConfig.schemastringWhich schema to be used when building URLs. Can be 'http' or 'https'.
"http"
gateway.nginxConfig.serverSnippetstringAllows appending custom configuration to the server block
""
gateway.nginxConfig.sslboolWhether ssl should be appended to the listen directive of the server block or not.
false
gateway.nodeSelectorobjectNode selector for gateway pods
{}
gateway.podAnnotationsobjectAnnotations for gateway pods
{}
gateway.podLabelsobjectAdditional labels for gateway pods
{}
gateway.podSecurityContextobjectThe SecurityContext for gateway containers
{
  "fsGroup": 101,
  "runAsGroup": 101,
  "runAsNonRoot": true,
  "runAsUser": 101
}
gateway.priorityClassNamestringThe name of the PriorityClass for gateway pods
null
gateway.readinessProbe.httpGet.pathstring
"/"
gateway.readinessProbe.httpGet.portstring
"http-metrics"
gateway.readinessProbe.initialDelaySecondsint
15
gateway.readinessProbe.timeoutSecondsint
1
gateway.replicasintNumber of replicas for the gateway
1
gateway.resourcesobjectResource requests and limits for the gateway
{}
gateway.service.annotationsobjectAnnotations for the gateway service
{}
gateway.service.clusterIPstringClusterIP of the gateway service
null
gateway.service.labelsobjectLabels for gateway service
{}
gateway.service.loadBalancerIPstringLoad balancer IPO address if service type is LoadBalancer
null
gateway.service.nodePortintNode port if service type is NodePort
null
gateway.service.portintPort of the gateway service
80
gateway.service.typestringType of the gateway service
"ClusterIP"
gateway.terminationGracePeriodSecondsintGrace period to allow the gateway to shutdown before it is killed
30
gateway.tolerationslistTolerations for gateway pods
[]
gateway.topologySpreadConstraintslistTopology Spread Constraints for gateway pods
[]
gateway.verboseLoggingboolEnable logging of 2xx and 3xx HTTP requests
true
global.clusterDomainstringconfigures cluster domain ("cluster.local" by default)
"cluster.local"
global.dnsNamespacestringconfigures DNS service namespace
"kube-system"
global.dnsServicestringconfigures DNS service name
"kube-dns"
global.image.registrystringOverrides the Docker registry globally for all images
null
global.priorityClassNamestringOverrides the priorityClassName for all pods
null
imagePullSecretslistImage pull secrets for Docker images
[]
indexGatewayobjectConfiguration for the index-gateway
{
  "affinity": {
    "podAntiAffinity": {
      "requiredDuringSchedulingIgnoredDuringExecution": [
        {
          "labelSelector": {
            "matchLabels": {
              "app.kubernetes.io/component": "index-gateway"
            }
          },
          "topologyKey": "kubernetes.io/hostname"
        }
      ]
    }
  },
  "appProtocol": {
    "grpc": ""
  },
  "extraArgs": [],
  "extraContainers": [],
  "extraEnv": [],
  "extraEnvFrom": [],
  "extraVolumeMounts": [],
  "extraVolumes": [],
  "hostAliases": [],
  "image": {
    "registry": null,
    "repository": null,
    "tag": null
  },
  "initContainers": [],
  "joinMemberlist": true,
  "maxUnavailable": null,
  "nodeSelector": {},
  "persistence": {
    "annotations": {},
    "enableStatefulSetAutoDeletePVC": false,
    "enabled": false,
    "inMemory": false,
    "size": "10Gi",
    "storageClass": null,
    "whenDeleted": "Retain",
    "whenScaled": "Retain"
  },
  "podAnnotations": {},
  "podLabels": {},
  "priorityClassName": null,
  "replicas": 0,
  "resources": {},
  "serviceAnnotations": {},
  "serviceLabels": {},
  "terminationGracePeriodSeconds": 300,
  "tolerations": [],
  "updateStrategy": {
    "type": "RollingUpdate"
  }
}
indexGateway.affinityobjectAffinity for index-gateway pods.
Hard node anti-affinity
indexGateway.appProtocolobjectSet the optional grpc service protocol. Ex: "grpc", "http2" or "https"
{
  "grpc": ""
}
indexGateway.extraArgslistAdditional CLI args for the index-gateway
[]
indexGateway.extraContainerslistContainers to add to the index-gateway pods
[]
indexGateway.extraEnvlistEnvironment variables to add to the index-gateway pods
[]
indexGateway.extraEnvFromlistEnvironment variables from secrets or configmaps to add to the index-gateway pods
[]
indexGateway.extraVolumeMountslistVolume mounts to add to the index-gateway pods
[]
indexGateway.extraVolumeslistVolumes to add to the index-gateway pods
[]
indexGateway.hostAliaseslisthostAliases to add
[]
indexGateway.image.registrystringThe Docker registry for the index-gateway image. Overrides `loki.image.registry`
null
indexGateway.image.repositorystringDocker image repository for the index-gateway image. Overrides `loki.image.repository`
null
indexGateway.image.tagstringDocker image tag for the index-gateway image. Overrides `loki.image.tag`
null
indexGateway.initContainerslistInit containers to add to the index-gateway pods
[]
indexGateway.joinMemberlistboolWhether the index gateway should join the memberlist hashring
true
indexGateway.maxUnavailablestringPod Disruption Budget maxUnavailable
null
indexGateway.nodeSelectorobjectNode selector for index-gateway pods
{}
indexGateway.persistence.annotationsobjectAnnotations for index gateway PVCs
{}
indexGateway.persistence.enableStatefulSetAutoDeletePVCboolEnable StatefulSetAutoDeletePVC feature
false
indexGateway.persistence.enabledboolEnable creating PVCs which is required when using boltdb-shipper
false
indexGateway.persistence.inMemoryboolUse emptyDir with ramdisk for storage. **Please note that all data in indexGateway will be lost on pod restart**
false
indexGateway.persistence.sizestringSize of persistent or memory disk
"10Gi"
indexGateway.persistence.storageClassstringStorage class to be used. If defined, storageClassName: . If set to "-", storageClassName: "", which disables dynamic provisioning. If empty or set to null, no storageClassName spec is set, choosing the default provisioner (gp2 on AWS, standard on GKE, AWS, and OpenStack).
null
indexGateway.podAnnotationsobjectAnnotations for index-gateway pods
{}
indexGateway.podLabelsobjectLabels for index-gateway pods
{}
indexGateway.priorityClassNamestringThe name of the PriorityClass for index-gateway pods
null
indexGateway.replicasintNumber of replicas for the index-gateway
0
indexGateway.resourcesobjectResource requests and limits for the index-gateway
{}
indexGateway.serviceAnnotationsobjectAnnotations for index-gateway service
{}
indexGateway.serviceLabelsobjectLabels for index-gateway service
{}
indexGateway.terminationGracePeriodSecondsintGrace period to allow the index-gateway to shutdown before it is killed.
300
indexGateway.tolerationslistTolerations for index-gateway pods
[]
indexGateway.updateStrategyobjectUpdateStrategy for the indexGateway StatefulSet.
{
  "type": "RollingUpdate"
}
indexGateway.updateStrategy.typestringOne of 'OnDelete' or 'RollingUpdate'
"RollingUpdate"
ingesterobjectConfiguration for the ingester
{
  "affinity": {
    "podAntiAffinity": {
      "requiredDuringSchedulingIgnoredDuringExecution": [
        {
          "labelSelector": {
            "matchLabels": {
              "app.kubernetes.io/component": "ingester"
            }
          },
          "topologyKey": "kubernetes.io/hostname"
        }
      ]
    }
  },
  "appProtocol": {
    "grpc": ""
  },
  "autoscaling": {
    "behavior": {
      "enabled": false,
      "scaleDown": {},
      "scaleUp": {}
    },
    "customMetrics": [],
    "enabled": false,
    "maxReplicas": 3,
    "minReplicas": 1,
    "targetCPUUtilizationPercentage": 60,
    "targetMemoryUtilizationPercentage": null
  },
  "command": null,
  "extraArgs": [],
  "extraContainers": [],
  "extraEnv": [],
  "extraEnvFrom": [],
  "extraVolumeMounts": [],
  "extraVolumes": [],
  "hostAliases": [],
  "image": {
    "registry": null,
    "repository": null,
    "tag": null
  },
  "initContainers": [],
  "lifecycle": {},
  "livenessProbe": {},
  "maxUnavailable": 1,
  "nodeSelector": {},
  "persistence": {
    "claims": [
      {
        "name": "data",
        "size": "10Gi",
        "storageClass": null
      }
    ],
    "enableStatefulSetAutoDeletePVC": false,
    "enabled": false,
    "inMemory": false,
    "whenDeleted": "Retain",
    "whenScaled": "Retain"
  },
  "podAnnotations": {},
  "podLabels": {},
  "priorityClassName": null,
  "readinessProbe": {},
  "replicas": 0,
  "resources": {},
  "serviceAnnotations": {},
  "serviceLabels": {},
  "terminationGracePeriodSeconds": 300,
  "tolerations": [],
  "topologySpreadConstraints": [
    {
      "labelSelector": {
        "matchLabels": {
          "app.kubernetes.io/component": "ingester"
        }
      },
      "maxSkew": 1,
      "topologyKey": "kubernetes.io/hostname",
      "whenUnsatisfiable": "ScheduleAnyway"
    }
  ],
  "updateStrategy": {
    "type": "RollingUpdate"
  },
  "zoneAwareReplication": {
    "enabled": true,
    "maxUnavailablePct": 33,
    "migration": {
      "enabled": false,
      "excludeDefaultZone": false,
      "readPath": false,
      "writePath": false
    },
    "zoneA": {
      "annotations": {},
      "extraAffinity": {},
      "nodeSelector": null,
      "podAnnotations": {}
    },
    "zoneB": {
      "annotations": {},
      "extraAffinity": {},
      "nodeSelector": null,
      "podAnnotations": {}
    },
    "zoneC": {
      "annotations": {},
      "extraAffinity": {},
      "nodeSelector": null,
      "podAnnotations": {}
    }
  }
}
ingester.affinityobjectAffinity for ingester pods. Ignored if zoneAwareReplication is enabled.
Hard node anti-affinity
ingester.appProtocolobjectAdds the appProtocol field to the ingester service. This allows ingester to work with istio protocol selection.
{
  "grpc": ""
}
ingester.appProtocol.grpcstringSet the optional grpc service protocol. Ex: "grpc", "http2" or "https"
""
ingester.autoscaling.behavior.enabledboolEnable autoscaling behaviours
false
ingester.autoscaling.behavior.scaleDownobjectdefine scale down policies, must conform to HPAScalingRules
{}
ingester.autoscaling.behavior.scaleUpobjectdefine scale up policies, must conform to HPAScalingRules
{}
ingester.autoscaling.customMetricslistAllows one to define custom metrics using the HPA/v2 schema (for example, Pods, Object or External metrics)
[]
ingester.autoscaling.enabledboolEnable autoscaling for the ingester
false
ingester.autoscaling.maxReplicasintMaximum autoscaling replicas for the ingester
3
ingester.autoscaling.minReplicasintMinimum autoscaling replicas for the ingester
1
ingester.autoscaling.targetCPUUtilizationPercentageintTarget CPU utilisation percentage for the ingester
60
ingester.autoscaling.targetMemoryUtilizationPercentagestringTarget memory utilisation percentage for the ingester
null
ingester.commandstringCommand to execute instead of defined in Docker image
null
ingester.extraArgslistAdditional CLI args for the ingester
[]
ingester.extraContainerslistContainers to add to the ingester pods
[]
ingester.extraEnvlistEnvironment variables to add to the ingester pods
[]
ingester.extraEnvFromlistEnvironment variables from secrets or configmaps to add to the ingester pods
[]
ingester.extraVolumeMountslistVolume mounts to add to the ingester pods
[]
ingester.extraVolumeslistVolumes to add to the ingester pods
[]
ingester.hostAliaseslisthostAliases to add
[]
ingester.image.registrystringThe Docker registry for the ingester image. Overrides `loki.image.registry`
null
ingester.image.repositorystringDocker image repository for the ingester image. Overrides `loki.image.repository`
null
ingester.image.tagstringDocker image tag for the ingester image. Overrides `loki.image.tag`
null
ingester.initContainerslistInit containers to add to the ingester pods
[]
ingester.lifecycleobjectLifecycle for the ingester container
{}
ingester.livenessProbeobjectliveness probe settings for ingester pods. If empty use `loki.livenessProbe`
{}
ingester.maxUnavailableintPod Disruption Budget maxUnavailable
1
ingester.nodeSelectorobjectNode selector for ingester pods
{}
ingester.persistence.claimslistList of the ingester PVCs

ingester.persistence.enableStatefulSetAutoDeletePVCboolEnable StatefulSetAutoDeletePVC feature
false
ingester.persistence.enabledboolEnable creating PVCs which is required when using boltdb-shipper
false
ingester.persistence.inMemoryboolUse emptyDir with ramdisk for storage. **Please note that all data in ingester will be lost on pod restart**
false
ingester.podAnnotationsobjectAnnotations for ingester pods
{}
ingester.podLabelsobjectLabels for ingester pods
{}
ingester.readinessProbeobjectreadiness probe settings for ingester pods. If empty, use `loki.readinessProbe`
{}
ingester.replicasintNumber of replicas for the ingester, when zoneAwareReplication.enabled is true, the total number of replicas will match this value with each zone having 1/3rd of the total replicas.
0
ingester.resourcesobjectResource requests and limits for the ingester
{}
ingester.serviceAnnotationsobjectAnnotations for ingestor service
{}
ingester.serviceLabelsobjectLabels for ingestor service
{}
ingester.terminationGracePeriodSecondsintGrace period to allow the ingester to shutdown before it is killed. Especially for the ingestor, this must be increased. It must be long enough so ingesters can be gracefully shutdown flushing/transferring all data and to successfully leave the member ring on shutdown.
300
ingester.tolerationslistTolerations for ingester pods
[]
ingester.topologySpreadConstraintslisttopologySpread for ingester pods.
Defaults to allow skew no more than 1 node
ingester.updateStrategyobjectUpdateStrategy for the ingester StatefulSets.
{
  "type": "RollingUpdate"
}
ingester.updateStrategy.typestringOne of 'OnDelete' or 'RollingUpdate'
"RollingUpdate"
ingester.zoneAwareReplicationobjectEnabling zone awareness on ingesters will create 3 statefulests where all writes will send a replica to each zone. This is primarily intended to accelerate rollout operations by allowing for multiple ingesters within a single zone to be shutdown and restart simultaneously (the remaining 2 zones will be guaranteed to have at least one copy of the data). Note: This can be used to run Loki over multiple cloud provider availability zones however this is not currently recommended as Loki is not optimized for this and cross zone network traffic costs can become extremely high extremely quickly. Even with zone awareness enabled, it is recommended to run Loki in a single availability zone.
{
  "enabled": true,
  "maxUnavailablePct": 33,
  "migration": {
    "enabled": false,
    "excludeDefaultZone": false,
    "readPath": false,
    "writePath": false
  },
  "zoneA": {
    "annotations": {},
    "extraAffinity": {},
    "nodeSelector": null,
    "podAnnotations": {}
  },
  "zoneB": {
    "annotations": {},
    "extraAffinity": {},
    "nodeSelector": null,
    "podAnnotations": {}
  },
  "zoneC": {
    "annotations": {},
    "extraAffinity": {},
    "nodeSelector": null,
    "podAnnotations": {}
  }
}
ingester.zoneAwareReplication.enabledboolEnable zone awareness.
true
ingester.zoneAwareReplication.maxUnavailablePctintThe percent of replicas in each zone that will be restarted at once. In a value of 0-100
33
ingester.zoneAwareReplication.migrationobjectThe migration block allows migrating non zone aware ingesters to zone aware ingesters.
{
  "enabled": false,
  "excludeDefaultZone": false,
  "readPath": false,
  "writePath": false
}
ingester.zoneAwareReplication.zoneAobjectzoneA configuration
{
  "annotations": {},
  "extraAffinity": {},
  "nodeSelector": null,
  "podAnnotations": {}
}
ingester.zoneAwareReplication.zoneA.annotationsobjectSpecific annotations to add to zone A statefulset
{}
ingester.zoneAwareReplication.zoneA.extraAffinityobjectoptionally define extra affinity rules, by default different zones are not allowed to schedule on the same host
{}
ingester.zoneAwareReplication.zoneA.nodeSelectorstringoptionally define a node selector for this zone
null
ingester.zoneAwareReplication.zoneA.podAnnotationsobjectSpecific annotations to add to zone A pods
{}
ingester.zoneAwareReplication.zoneB.annotationsobjectSpecific annotations to add to zone B statefulset
{}
ingester.zoneAwareReplication.zoneB.extraAffinityobjectoptionally define extra affinity rules, by default different zones are not allowed to schedule on the same host
{}
ingester.zoneAwareReplication.zoneB.nodeSelectorstringoptionally define a node selector for this zone
null
ingester.zoneAwareReplication.zoneB.podAnnotationsobjectSpecific annotations to add to zone B pods
{}
ingester.zoneAwareReplication.zoneC.annotationsobjectSpecific annotations to add to zone C statefulset
{}
ingester.zoneAwareReplication.zoneC.extraAffinityobjectoptionally define extra affinity rules, by default different zones are not allowed to schedule on the same host
{}
ingester.zoneAwareReplication.zoneC.nodeSelectorstringoptionally define a node selector for this zone
null
ingester.zoneAwareReplication.zoneC.podAnnotationsobjectSpecific annotations to add to zone C pods
{}
ingressobjectIngress configuration Use either this ingress or the gateway, but not both at once. If you enable this, make sure to disable the gateway. You'll need to supply authn configuration for your ingress controller.
{
  "annotations": {},
  "enabled": false,
  "hosts": [
    "loki.example.com"
  ],
  "ingressClassName": "",
  "labels": {},
  "paths": {
    "distributor": [
      "/api/prom/push",
      "/loki/api/v1/push",
      "/otlp/v1/logs"
    ],
    "queryFrontend": [
      "/api/prom/query",
      "/api/prom/label",
      "/api/prom/series",
      "/api/prom/tail",
      "/loki/api/v1/query",
      "/loki/api/v1/query_range",
      "/loki/api/v1/tail",
      "/loki/api/v1/label",
      "/loki/api/v1/labels",
      "/loki/api/v1/series",
      "/loki/api/v1/index/stats",
      "/loki/api/v1/index/volume",
      "/loki/api/v1/index/volume_range",
      "/loki/api/v1/format_query",
      "/loki/api/v1/detected_field",
      "/loki/api/v1/detected_fields",
      "/loki/api/v1/detected_labels",
      "/loki/api/v1/patterns"
    ],
    "ruler": [
      "/api/prom/rules",
      "/api/prom/api/v1/rules",
      "/api/prom/api/v1/alerts",
      "/loki/api/v1/rules",
      "/prometheus/api/v1/rules",
      "/prometheus/api/v1/alerts"
    ]
  },
  "tls": []
}
ingress.hostslistHosts configuration for the ingress, passed through the `tpl` function to allow templating
[
  "loki.example.com"
]
ingress.paths.distributorlistPaths that are exposed by Loki Distributor. If deployment mode is Distributed, the requests are forwarded to the service: `{{"loki.distributorFullname"}}`. If deployment mode is SimpleScalable, the requests are forwarded to write k8s service: `{{"loki.writeFullname"}}`. If deployment mode is SingleBinary, the requests are forwarded to the central/single k8s service: `{{"loki.singleBinaryFullname"}}`
[
  "/api/prom/push",
  "/loki/api/v1/push",
  "/otlp/v1/logs"
]
ingress.paths.queryFrontendlistPaths that are exposed by Loki Query Frontend. If deployment mode is Distributed, the requests are forwarded to the service: `{{"loki.queryFrontendFullname"}}`. If deployment mode is SimpleScalable, the requests are forwarded to write k8s service: `{{"loki.readFullname"}}`. If deployment mode is SingleBinary, the requests are forwarded to the central/single k8s service: `{{"loki.singleBinaryFullname"}}`
[
  "/api/prom/query",
  "/api/prom/label",
  "/api/prom/series",
  "/api/prom/tail",
  "/loki/api/v1/query",
  "/loki/api/v1/query_range",
  "/loki/api/v1/tail",
  "/loki/api/v1/label",
  "/loki/api/v1/labels",
  "/loki/api/v1/series",
  "/loki/api/v1/index/stats",
  "/loki/api/v1/index/volume",
  "/loki/api/v1/index/volume_range",
  "/loki/api/v1/format_query",
  "/loki/api/v1/detected_field",
  "/loki/api/v1/detected_fields",
  "/loki/api/v1/detected_labels",
  "/loki/api/v1/patterns"
]
ingress.paths.rulerlistPaths that are exposed by Loki Ruler. If deployment mode is Distributed, the requests are forwarded to the service: `{{"loki.rulerFullname"}}`. If deployment mode is SimpleScalable, the requests are forwarded to k8s service: `{{"loki.backendFullname"}}`. If deployment mode is SimpleScalable but `read.legacyReadTarget` is `true`, the requests are forwarded to k8s service: `{{"loki.readFullname"}}`. If deployment mode is SingleBinary, the requests are forwarded to the central/single k8s service: `{{"loki.singleBinaryFullname"}}`
[
  "/api/prom/rules",
  "/api/prom/api/v1/rules",
  "/api/prom/api/v1/alerts",
  "/loki/api/v1/rules",
  "/prometheus/api/v1/rules",
  "/prometheus/api/v1/alerts"
]
ingress.tlslistTLS configuration for the ingress. Hosts passed through the `tpl` function to allow templating
[]
kubeVersionOverridestringOverrides the version used to determine compatibility of resources with the target Kubernetes cluster. This is useful when using `helm template`, because then helm will use the client version of kubectl as the Kubernetes version, which may or may not match your cluster's server version. Example: 'v1.24.4'. Set to null to use the version that helm devises.
null
kubectlImageobjectkubetclImage is used in the enterprise provisioner and tokengen jobs
{
  "digest": null,
  "pullPolicy": "IfNotPresent",
  "registry": "docker.io",
  "repository": "bitnami/kubectl",
  "tag": null
}
kubectlImage.digeststringOverrides the image tag with an image digest
null
kubectlImage.pullPolicystringDocker image pull policy
"IfNotPresent"
kubectlImage.registrystringThe Docker registry
"docker.io"
kubectlImage.repositorystringDocker image repository
"bitnami/kubectl"
kubectlImage.tagstringOverrides the image tag whose default is the chart's appVersion
null
lokiobjectConfiguration for running Loki
See values.yaml
loki.analyticsobjectOptional analytics configuration
{}
loki.annotationsobjectCommon annotations for all deployments/StatefulSets
{}
loki.commonConfigobjectCheck https://grafana.com/docs/loki/latest/configuration/#common_config for more info on how to provide a common configuration
{
  "compactor_address": "{{ include \"loki.compactorAddress\" . }}",
  "path_prefix": "/var/loki",
  "replication_factor": 3
}
loki.compactorobjectOptional compactor configuration
{}
loki.configstringConfig file contents for Loki
See values.yaml
loki.configObjectNamestringThe name of the object which Loki will mount as a volume containing the config. If the configStorageType is Secret, this will be the name of the Secret, if it is ConfigMap, this will be the name of the ConfigMap. The value will be passed through tpl.
"{{ include \"loki.name\" . }}"
loki.configStorageTypestringDefines what kind of object stores the configuration, a ConfigMap or a Secret. In order to move sensitive information (such as credentials) from the ConfigMap/Secret to a more secure location (e.g. vault), it is possible to use [environment variables in the configuration](https://grafana.com/docs/loki/latest/configuration/#use-environment-variables-in-the-configuration). Such environment variables can be then stored in a separate Secret and injected via the global.extraEnvFrom value. For details about environment injection from a Secret please see [Secrets](https://kubernetes.io/docs/concepts/configuration/secret/#use-case-as-container-environment-variables).
"ConfigMap"
loki.containerSecurityContextobjectThe SecurityContext for Loki containers
{
  "allowPrivilegeEscalation": false,
  "capabilities": {
    "drop": [
      "ALL"
    ]
  },
  "readOnlyRootFilesystem": true
}
loki.distributorobjectOptional distributor configuration
{}
loki.enableServiceLinksboolShould enableServiceLinks be enabled. Default to enable
true
loki.extraMemberlistConfigobjectExtra memberlist configuration
{}
loki.generatedConfigObjectNamestringThe name of the Secret or ConfigMap that will be created by this chart. If empty, no configmap or secret will be created. The value will be passed through tpl.
"{{ include \"loki.name\" . }}"
loki.image.digeststringOverrides the image tag with an image digest
null
loki.image.pullPolicystringDocker image pull policy
"IfNotPresent"
loki.image.registrystringThe Docker registry
"docker.io"
loki.image.repositorystringDocker image repository
"grafana/loki"
loki.image.tagstringOverrides the image tag whose default is the chart's appVersion
null
loki.index_gatewayobjectOptional index gateway configuration
{
  "mode": "simple"
}
loki.ingesterobjectOptional ingester configuration
{}
loki.limits_configobjectLimits config
{
  "max_cache_freshness_per_query": "10m",
  "query_timeout": "300s",
  "reject_old_samples": true,
  "reject_old_samples_max_age": "168h",
  "split_queries_by_interval": "15m",
  "volume_enabled": true
}
loki.memberlistConfigobjectmemberlist configuration (overrides embedded default)
{}
loki.memcachedobjectConfigure memcached as an external cache for chunk and results cache. Disabled by default must enable and specify a host for each cache you would like to use.
{
  "chunk_cache": {
    "batch_size": 256,
    "enabled": false,
    "host": "",
    "parallelism": 10,
    "service": "memcached-client"
  },
  "results_cache": {
    "default_validity": "12h",
    "enabled": false,
    "host": "",
    "service": "memcached-client",
    "timeout": "500ms"
  }
}
loki.pattern_ingesterobjectOptional pattern ingester configuration
{
  "enabled": false
}
loki.podAnnotationsobjectCommon annotations for all pods
{}
loki.podLabelsobjectCommon labels for all pods
{}
loki.podSecurityContextobjectThe SecurityContext for Loki pods
{
  "fsGroup": 10001,
  "runAsGroup": 10001,
  "runAsNonRoot": true,
  "runAsUser": 10001
}
loki.querierobjectOptional querier configuration
{}
loki.query_rangeobjectOptional querier configuration
{}
loki.query_schedulerobjectAdditional query scheduler config
{}
loki.revisionHistoryLimitintThe number of old ReplicaSets to retain to allow rollback
10
loki.rulerConfigobjectCheck https://grafana.com/docs/loki/latest/configuration/#ruler for more info on configuring ruler
{}
loki.runtimeConfigobjectProvides a reloadable runtime configuration file for some specific configuration
{}
loki.schemaConfigobjectCheck https://grafana.com/docs/loki/latest/configuration/#schema_config for more info on how to configure schemas
{}
loki.serverobjectCheck https://grafana.com/docs/loki/latest/configuration/#server for more info on the server configuration.
{
  "grpc_listen_port": 9095,
  "http_listen_port": 3100,
  "http_server_read_timeout": "600s",
  "http_server_write_timeout": "600s"
}
loki.serviceAnnotationsobjectCommon annotations for all services
{}
loki.serviceLabelsobjectCommon labels for all services
{}
loki.storageobjectStorage config. Providing this will automatically populate all necessary storage configs in the templated config.
{
  "azure": {
    "accountKey": null,
    "accountName": null,
    "chunkDelimiter": null,
    "connectionString": null,
    "endpointSuffix": null,
    "requestTimeout": null,
    "useFederatedToken": false,
    "useManagedIdentity": false,
    "userAssignedId": null
  },
  "filesystem": {
    "admin_api_directory": "/var/loki/admin",
    "chunks_directory": "/var/loki/chunks",
    "rules_directory": "/var/loki/rules"
  },
  "gcs": {
    "chunkBufferSize": 0,
    "enableHttp2": true,
    "requestTimeout": "0s"
  },
  "s3": {
    "accessKeyId": null,
    "backoff_config": {},
    "disable_dualstack": false,
    "endpoint": null,
    "http_config": {},
    "insecure": false,
    "region": null,
    "s3": null,
    "s3ForcePathStyle": false,
    "secretAccessKey": null,
    "signatureVersion": null
  },
  "swift": {
    "auth_url": null,
    "auth_version": null,
    "connect_timeout": null,
    "container_name": null,
    "domain_id": null,
    "domain_name": null,
    "internal": null,
    "max_retries": null,
    "password": null,
    "project_domain_id": null,
    "project_domain_name": null,
    "project_id": null,
    "project_name": null,
    "region_name": null,
    "request_timeout": null,
    "user_domain_id": null,
    "user_domain_name": null,
    "user_id": null,
    "username": null
  },
  "type": "s3"
}
loki.storage.s3.backoff_configobjectCheck https://grafana.com/docs/loki/latest/configure/#s3_storage_config for more info on how to provide a backoff_config
{}
loki.storage_configobjectAdditional storage config
{
  "bloom_shipper": {
    "working_directory": "/var/loki/data/bloomshipper"
  },
  "boltdb_shipper": {
    "index_gateway_client": {
      "server_address": "{{ include \"loki.indexGatewayAddress\" . }}"
    }
  },
  "hedging": {
    "at": "250ms",
    "max_per_second": 20,
    "up_to": 3
  },
  "tsdb_shipper": {
    "index_gateway_client": {
      "server_address": "{{ include \"loki.indexGatewayAddress\" . }}"
    }
  }
}
loki.structuredConfigobjectStructured loki configuration, takes precedence over `loki.config`, `loki.schemaConfig`, `loki.storageConfig`
{}
loki.tenantslistTenants list to be created on nginx htpasswd file, with name and password keys
[]
loki.tracingobjectEnable tracing
{
  "enabled": false
}
loki.useTestSchemaboola real Loki install requires a proper schemaConfig defined above this, however for testing or playing around you can enable useTestSchema
false
lokiCanary.annotationsobjectAdditional annotations for the `loki-canary` Daemonset
{}
lokiCanary.dnsConfigobjectDNS config for canary pods
{}
lokiCanary.enabledbool
true
lokiCanary.extraArgslistAdditional CLI arguments for the `loki-canary' command
[]
lokiCanary.extraEnvlistEnvironment variables to add to the canary pods
[]
lokiCanary.extraEnvFromlistEnvironment variables from secrets or configmaps to add to the canary pods
[]
lokiCanary.extraVolumeMountslistVolume mounts to add to the canary pods
[]
lokiCanary.extraVolumeslistVolumes to add to the canary pods
[]
lokiCanary.imageobjectImage to use for loki canary
{
  "digest": null,
  "pullPolicy": "IfNotPresent",
  "registry": "docker.io",
  "repository": "grafana/loki-canary",
  "tag": null
}
lokiCanary.image.digeststringOverrides the image tag with an image digest
null
lokiCanary.image.pullPolicystringDocker image pull policy
"IfNotPresent"
lokiCanary.image.registrystringThe Docker registry
"docker.io"
lokiCanary.image.repositorystringDocker image repository
"grafana/loki-canary"
lokiCanary.image.tagstringOverrides the image tag whose default is the chart's appVersion
null
lokiCanary.labelnamestringThe name of the label to look for at loki when doing the checks.
"pod"
lokiCanary.nodeSelectorobjectNode selector for canary pods
{}
lokiCanary.podLabelsobjectAdditional labels for each `loki-canary` pod
{}
lokiCanary.priorityClassNamestringThe name of the PriorityClass for loki-canary pods
null
lokiCanary.pushbool
true
lokiCanary.resourcesobjectResource requests and limits for the canary
{}
lokiCanary.service.annotationsobjectAnnotations for loki-canary Service
{}
lokiCanary.service.labelsobjectAdditional labels for loki-canary Service
{}
lokiCanary.tolerationslistTolerations for canary pods
[]
lokiCanary.updateStrategyobjectUpdate strategy for the `loki-canary` Daemonset pods
{
  "rollingUpdate": {
    "maxUnavailable": 1
  },
  "type": "RollingUpdate"
}
memberlist.service.annotationsobject
{}
memberlist.service.publishNotReadyAddressesbool
false
memcached.containerSecurityContextobjectThe SecurityContext for memcached containers
{
  "allowPrivilegeEscalation": false,
  "capabilities": {
    "drop": [
      "ALL"
    ]
  },
  "readOnlyRootFilesystem": true
}
memcached.image.pullPolicystringMemcached Docker image pull policy
"IfNotPresent"
memcached.image.repositorystringMemcached Docker image repository
"memcached"
memcached.image.tagstringMemcached Docker image tag
"1.6.23-alpine"
memcached.podSecurityContextobjectThe SecurityContext override for memcached pods
{
  "fsGroup": 11211,
  "runAsGroup": 11211,
  "runAsNonRoot": true,
  "runAsUser": 11211
}
memcached.priorityClassNamestringThe name of the PriorityClass for memcached pods
null
memcachedExporter.containerSecurityContextobjectThe SecurityContext for memcached exporter containers
{
  "allowPrivilegeEscalation": false,
  "capabilities": {
    "drop": [
      "ALL"
    ]
  },
  "readOnlyRootFilesystem": true
}
memcachedExporter.enabledboolWhether memcached metrics should be exported
true
memcachedExporter.extraArgsobjectExtra args to add to the exporter container. Example: extraArgs: memcached.tls.enable: true memcached.tls.cert-file: /certs/cert.crt memcached.tls.key-file: /certs/cert.key memcached.tls.ca-file: /certs/ca.crt memcached.tls.insecure-skip-verify: false memcached.tls.server-name: memcached
{}
memcachedExporter.image.pullPolicystring
"IfNotPresent"
memcachedExporter.image.repositorystring
"prom/memcached-exporter"
memcachedExporter.image.tagstring
"v0.14.2"
memcachedExporter.resources.limitsobject
{}
memcachedExporter.resources.requestsobject
{}
migrateobjectOptions that may be necessary when performing a migration from another helm chart
{
  "fromDistributed": {
    "enabled": false,
    "memberlistService": ""
  }
}
migrate.fromDistributedobjectWhen migrating from a distributed chart like loki-distributed or enterprise-logs
{
  "enabled": false,
  "memberlistService": ""
}
migrate.fromDistributed.enabledboolSet to true if migrating from a distributed helm chart
false
migrate.fromDistributed.memberlistServicestringIf migrating from a distributed service, provide the distributed deployment's memberlist service DNS so the new deployment can join its ring.
""
minioobjectConfiguration for the minio subchart
{
  "address": null,
  "buckets": [
    {
      "name": "chunks",
      "policy": "none",
      "purge": false
    },
    {
      "name": "ruler",
      "policy": "none",
      "purge": false
    },
    {
      "name": "admin",
      "policy": "none",
      "purge": false
    }
  ],
  "drivesPerNode": 2,
  "enabled": false,
  "persistence": {
    "annotations": {},
    "size": "5Gi"
  },
  "replicas": 1,
  "resources": {
    "requests": {
      "cpu": "100m",
      "memory": "128Mi"
    }
  },
  "rootPassword": "supersecret",
  "rootUser": "enterprise-logs"
}
monitoringobjectDEPRECATED Monitoring section determines which monitoring features to enable, this section is being replaced by https://github.com/grafana/meta-monitoring-chart
{
  "dashboards": {
    "annotations": {},
    "enabled": false,
    "labels": {
      "grafana_dashboard": "1"
    },
    "namespace": null
  },
  "rules": {
    "additionalGroups": [],
    "additionalRuleLabels": {},
    "alerting": true,
    "annotations": {},
    "disabled": {},
    "enabled": false,
    "labels": {},
    "namespace": null
  },
  "selfMonitoring": {
    "enabled": false,
    "grafanaAgent": {
      "annotations": {},
      "enableConfigReadAPI": false,
      "installOperator": false,
      "labels": {},
      "priorityClassName": null,
      "resources": {},
      "tolerations": []
    },
    "logsInstance": {
      "annotations": {},
      "clients": null,
      "labels": {}
    },
    "podLogs": {
      "additionalPipelineStages": [],
      "annotations": {},
      "apiVersion": "monitoring.grafana.com/v1alpha1",
      "labels": {},
      "relabelings": []
    },
    "tenant": {
      "name": "self-monitoring",
      "password": null,
      "secretNamespace": "{{ .Release.Namespace }}"
    }
  },
  "serviceMonitor": {
    "annotations": {},
    "enabled": false,
    "interval": "15s",
    "labels": {},
    "metricRelabelings": [],
    "metricsInstance": {
      "annotations": {},
      "enabled": true,
      "labels": {},
      "remoteWrite": null
    },
    "namespaceSelector": {},
    "relabelings": [],
    "scheme": "http",
    "scrapeTimeout": null,
    "tlsConfig": null
  }
}
monitoring.dashboards.annotationsobjectAdditional annotations for the dashboards ConfigMap
{}
monitoring.dashboards.enabledboolIf enabled, create configmap with dashboards for monitoring Loki
false
monitoring.dashboards.labelsobjectLabels for the dashboards ConfigMap
{
  "grafana_dashboard": "1"
}
monitoring.dashboards.namespacestringAlternative namespace to create dashboards ConfigMap in
null
monitoring.rulesobjectDEPRECATED Recording rules for monitoring Loki, required for some dashboards
{
  "additionalGroups": [],
  "additionalRuleLabels": {},
  "alerting": true,
  "annotations": {},
  "disabled": {},
  "enabled": false,
  "labels": {},
  "namespace": null
}
monitoring.rules.additionalGroupslistAdditional groups to add to the rules file
[]
monitoring.rules.additionalRuleLabelsobjectAdditional labels for PrometheusRule alerts
{}
monitoring.rules.alertingboolInclude alerting rules
true
monitoring.rules.annotationsobjectAdditional annotations for the rules PrometheusRule resource
{}
monitoring.rules.disabledobjectIf you disable all the alerts and keep .monitoring.rules.alerting set to true, the chart will fail to render.
{}
monitoring.rules.enabledboolIf enabled, create PrometheusRule resource with Loki recording rules
false
monitoring.rules.labelsobjectAdditional labels for the rules PrometheusRule resource
{}
monitoring.rules.namespacestringAlternative namespace to create PrometheusRule resources in
null
monitoring.selfMonitoringobjectDEPRECATED Self monitoring determines whether Loki should scrape its own logs. This feature currently relies on the Grafana Agent Operator being installed, which is installed by default using the grafana-agent-operator sub-chart. It will create custom resources for GrafanaAgent, LogsInstance, and PodLogs to configure scrape configs to scrape its own logs with the labels expected by the included dashboards.
{
  "enabled": false,
  "grafanaAgent": {
    "annotations": {},
    "enableConfigReadAPI": false,
    "installOperator": false,
    "labels": {},
    "priorityClassName": null,
    "resources": {},
    "tolerations": []
  },
  "logsInstance": {
    "annotations": {},
    "clients": null,
    "labels": {}
  },
  "podLogs": {
    "additionalPipelineStages": [],
    "annotations": {},
    "apiVersion": "monitoring.grafana.com/v1alpha1",
    "labels": {},
    "relabelings": []
  },
  "tenant": {
    "name": "self-monitoring",
    "password": null,
    "secretNamespace": "{{ .Release.Namespace }}"
  }
}
monitoring.selfMonitoring.grafanaAgentobjectDEPRECATED Grafana Agent configuration
{
  "annotations": {},
  "enableConfigReadAPI": false,
  "installOperator": false,
  "labels": {},
  "priorityClassName": null,
  "resources": {},
  "tolerations": []
}
monitoring.selfMonitoring.grafanaAgent.annotationsobjectGrafana Agent annotations
{}
monitoring.selfMonitoring.grafanaAgent.enableConfigReadAPIboolEnable the config read api on port 8080 of the agent
false
monitoring.selfMonitoring.grafanaAgent.installOperatorboolDEPRECATED Controls whether to install the Grafana Agent Operator and its CRDs. Note that helm will not install CRDs if this flag is enabled during an upgrade. In that case install the CRDs manually from https://github.com/grafana/agent/tree/main/production/operator/crds
false
monitoring.selfMonitoring.grafanaAgent.labelsobjectAdditional Grafana Agent labels
{}
monitoring.selfMonitoring.grafanaAgent.priorityClassNamestringThe name of the PriorityClass for GrafanaAgent pods
null
monitoring.selfMonitoring.grafanaAgent.resourcesobjectResource requests and limits for the grafanaAgent pods
{}
monitoring.selfMonitoring.grafanaAgent.tolerationslistTolerations for GrafanaAgent pods
[]
monitoring.selfMonitoring.logsInstance.annotationsobjectLogsInstance annotations
{}
monitoring.selfMonitoring.logsInstance.clientsstringAdditional clients for remote write
null
monitoring.selfMonitoring.logsInstance.labelsobjectAdditional LogsInstance labels
{}
monitoring.selfMonitoring.podLogs.additionalPipelineStageslistAdditional pipeline stages to process logs after scraping https://grafana.com/docs/agent/latest/operator/api/#pipelinestagespec-a-namemonitoringgrafanacomv1alpha1pipelinestagespeca
[]
monitoring.selfMonitoring.podLogs.annotationsobjectPodLogs annotations
{}
monitoring.selfMonitoring.podLogs.apiVersionstringPodLogs version
"monitoring.grafana.com/v1alpha1"
monitoring.selfMonitoring.podLogs.labelsobjectAdditional PodLogs labels
{}
monitoring.selfMonitoring.podLogs.relabelingslistPodLogs relabel configs to apply to samples before scraping https://github.com/prometheus-operator/prometheus-operator/blob/master/Documentation/api.md#relabelconfig
[]
monitoring.selfMonitoring.tenantobjectTenant to use for self monitoring
{
  "name": "self-monitoring",
  "password": null,
  "secretNamespace": "{{ .Release.Namespace }}"
}
monitoring.selfMonitoring.tenant.namestringName of the tenant
"self-monitoring"
monitoring.selfMonitoring.tenant.passwordstringPassword of the gateway for Basic auth
null
monitoring.selfMonitoring.tenant.secretNamespacestringNamespace to create additional tenant token secret in. Useful if your Grafana instance is in a separate namespace. Token will still be created in the canary namespace.
"{{ .Release.Namespace }}"
monitoring.serviceMonitor.annotationsobjectServiceMonitor annotations
{}
monitoring.serviceMonitor.enabledboolIf enabled, ServiceMonitor resources for Prometheus Operator are created
false
monitoring.serviceMonitor.intervalstringServiceMonitor scrape interval Default is 15s because included recording rules use a 1m rate, and scrape interval needs to be at least 1/4 rate interval.
"15s"
monitoring.serviceMonitor.labelsobjectAdditional ServiceMonitor labels
{}
monitoring.serviceMonitor.metricRelabelingslistServiceMonitor metric relabel configs to apply to samples before ingestion https://github.com/prometheus-operator/prometheus-operator/blob/main/Documentation/api.md#endpoint
[]
monitoring.serviceMonitor.metricsInstanceobjectIf defined, will create a MetricsInstance for the Grafana Agent Operator.
{
  "annotations": {},
  "enabled": true,
  "labels": {},
  "remoteWrite": null
}
monitoring.serviceMonitor.metricsInstance.annotationsobjectMetricsInstance annotations
{}
monitoring.serviceMonitor.metricsInstance.enabledboolIf enabled, MetricsInstance resources for Grafana Agent Operator are created
true
monitoring.serviceMonitor.metricsInstance.labelsobjectAdditional MetricsInstance labels
{}
monitoring.serviceMonitor.metricsInstance.remoteWritestringIf defined a MetricsInstance will be created to remote write metrics.
null
monitoring.serviceMonitor.namespaceSelectorobjectNamespace selector for ServiceMonitor resources
{}
monitoring.serviceMonitor.relabelingslistServiceMonitor relabel configs to apply to samples before scraping https://github.com/prometheus-operator/prometheus-operator/blob/master/Documentation/api.md#relabelconfig
[]
monitoring.serviceMonitor.schemestringServiceMonitor will use http by default, but you can pick https as well
"http"
monitoring.serviceMonitor.scrapeTimeoutstringServiceMonitor scrape timeout in Go duration format (e.g. 15s)
null
monitoring.serviceMonitor.tlsConfigstringServiceMonitor will use these tlsConfig settings to make the health check requests
null
nameOverridestringOverrides the chart's name
null
networkPolicy.alertmanager.namespaceSelectorobjectSpecifies the namespace the alertmanager is running in
{}
networkPolicy.alertmanager.podSelectorobjectSpecifies the alertmanager Pods. As this is cross-namespace communication, you also need the namespaceSelector.
{}
networkPolicy.alertmanager.portintSpecify the alertmanager port used for alerting
9093
networkPolicy.discovery.namespaceSelectorobjectSpecifies the namespace the discovery Pods are running in
{}
networkPolicy.discovery.podSelectorobjectSpecifies the Pods labels used for discovery. As this is cross-namespace communication, you also need the namespaceSelector.
{}
networkPolicy.discovery.portintSpecify the port used for discovery
null
networkPolicy.egressKubeApiserver.enabledboolEnable additional cilium egress rules to kube-apiserver for backend.
false
networkPolicy.egressWorld.enabledboolEnable additional cilium egress rules to external world for write, read and backend.
false
networkPolicy.enabledboolSpecifies whether Network Policies should be created
false
networkPolicy.externalStorage.cidrslistSpecifies specific network CIDRs you want to limit access to
[]
networkPolicy.externalStorage.portslistSpecify the port used for external storage, e.g. AWS S3
[]
networkPolicy.flavorstringSpecifies whether the policies created will be standard Network Policies (flavor: kubernetes) or Cilium Network Policies (flavor: cilium)
"kubernetes"
networkPolicy.ingress.namespaceSelectorobjectSpecifies the namespaces which are allowed to access the http port
{}
networkPolicy.ingress.podSelectorobjectSpecifies the Pods which are allowed to access the http port. As this is cross-namespace communication, you also need the namespaceSelector.
{}
networkPolicy.metrics.cidrslistSpecifies specific network CIDRs which are allowed to access the metrics port. In case you use namespaceSelector, you also have to specify your kubelet networks here. The metrics ports are also used for probes.
[]
networkPolicy.metrics.namespaceSelectorobjectSpecifies the namespaces which are allowed to access the metrics port
{}
networkPolicy.metrics.podSelectorobjectSpecifies the Pods which are allowed to access the metrics port. As this is cross-namespace communication, you also need the namespaceSelector.
{}
patternIngesterobjectConfiguration for the pattern ingester
{
  "affinity": {
    "podAntiAffinity": {
      "requiredDuringSchedulingIgnoredDuringExecution": [
        {
          "labelSelector": {
            "matchLabels": {
              "app.kubernetes.io/component": "pattern-ingester"
            }
          },
          "topologyKey": "kubernetes.io/hostname"
        }
      ]
    }
  },
  "appProtocol": {
    "grpc": ""
  },
  "command": null,
  "extraArgs": [],
  "extraContainers": [],
  "extraEnv": [],
  "extraEnvFrom": [],
  "extraVolumeMounts": [],
  "extraVolumes": [],
  "hostAliases": [],
  "image": {
    "registry": null,
    "repository": null,
    "tag": null
  },
  "initContainers": [],
  "livenessProbe": {},
  "nodeSelector": {},
  "persistence": {
    "annotations": {},
    "claims": [
      {
        "name": "data",
        "size": "10Gi",
        "storageClass": null
      }
    ],
    "enableStatefulSetAutoDeletePVC": false,
    "enabled": false,
    "size": "10Gi",
    "storageClass": null,
    "whenDeleted": "Retain",
    "whenScaled": "Retain"
  },
  "podAnnotations": {},
  "podLabels": {},
  "priorityClassName": null,
  "readinessProbe": {},
  "replicas": 0,
  "resources": {},
  "serviceAccount": {
    "annotations": {},
    "automountServiceAccountToken": true,
    "create": false,
    "imagePullSecrets": [],
    "name": null
  },
  "serviceAnnotations": {},
  "serviceLabels": {},
  "terminationGracePeriodSeconds": 30,
  "tolerations": []
}
patternIngester.affinityobjectAffinity for pattern ingester pods.
Hard node anti-affinity
patternIngester.appProtocolobjectSet the optional grpc service protocol. Ex: "grpc", "http2" or "https"
{
  "grpc": ""
}
patternIngester.commandstringCommand to execute instead of defined in Docker image
null
patternIngester.extraArgslistAdditional CLI args for the pattern ingester
[]
patternIngester.extraContainerslistContainers to add to the pattern ingester pods
[]
patternIngester.extraEnvlistEnvironment variables to add to the pattern ingester pods
[]
patternIngester.extraEnvFromlistEnvironment variables from secrets or configmaps to add to the pattern ingester pods
[]
patternIngester.extraVolumeMountslistVolume mounts to add to the pattern ingester pods
[]
patternIngester.extraVolumeslistVolumes to add to the pattern ingester pods
[]
patternIngester.hostAliaseslisthostAliases to add
[]
patternIngester.image.registrystringThe Docker registry for the pattern ingester image. Overrides `loki.image.registry`
null
patternIngester.image.repositorystringDocker image repository for the pattern ingester image. Overrides `loki.image.repository`
null
patternIngester.image.tagstringDocker image tag for the pattern ingester image. Overrides `loki.image.tag`
null
patternIngester.initContainerslistInit containers to add to the pattern ingester pods
[]
patternIngester.livenessProbeobjectliveness probe settings for ingester pods. If empty use `loki.livenessProbe`
{}
patternIngester.nodeSelectorobjectNode selector for pattern ingester pods
{}
patternIngester.persistence.annotationsobjectAnnotations for pattern ingester PVCs
{}
patternIngester.persistence.claimslistList of the pattern ingester PVCs

patternIngester.persistence.enableStatefulSetAutoDeletePVCboolEnable StatefulSetAutoDeletePVC feature
false
patternIngester.persistence.enabledboolEnable creating PVCs for the pattern ingester
false
patternIngester.persistence.sizestringSize of persistent disk
"10Gi"
patternIngester.persistence.storageClassstringStorage class to be used. If defined, storageClassName: . If set to "-", storageClassName: "", which disables dynamic provisioning. If empty or set to null, no storageClassName spec is set, choosing the default provisioner (gp2 on AWS, standard on GKE, AWS, and OpenStack).
null
patternIngester.podAnnotationsobjectAnnotations for pattern ingester pods
{}
patternIngester.podLabelsobjectLabels for pattern ingester pods
{}
patternIngester.priorityClassNamestringThe name of the PriorityClass for pattern ingester pods
null
patternIngester.readinessProbeobjectreadiness probe settings for ingester pods. If empty, use `loki.readinessProbe`
{}
patternIngester.replicasintNumber of replicas for the pattern ingester
0
patternIngester.resourcesobjectResource requests and limits for the pattern ingester
{}
patternIngester.serviceAccount.annotationsobjectAnnotations for the pattern ingester service account
{}
patternIngester.serviceAccount.automountServiceAccountTokenboolSet this toggle to false to opt out of automounting API credentials for the service account
true
patternIngester.serviceAccount.imagePullSecretslistImage pull secrets for the pattern ingester service account
[]
patternIngester.serviceAccount.namestringThe name of the ServiceAccount to use for the pattern ingester. If not set and create is true, a name is generated by appending "-pattern-ingester" to the common ServiceAccount.
null
patternIngester.serviceAnnotationsobjectAnnotations for pattern ingester service
{}
patternIngester.serviceLabelsobjectLabels for pattern ingester service
{}
patternIngester.terminationGracePeriodSecondsintGrace period to allow the pattern ingester to shutdown before it is killed
30
patternIngester.tolerationslistTolerations for pattern ingester pods
[]
querierobjectConfiguration for the querier
{
  "affinity": {
    "podAntiAffinity": {
      "requiredDuringSchedulingIgnoredDuringExecution": [
        {
          "labelSelector": {
            "matchLabels": {
              "app.kubernetes.io/component": "querier"
            }
          },
          "topologyKey": "kubernetes.io/hostname"
        }
      ]
    }
  },
  "appProtocol": {
    "grpc": ""
  },
  "autoscaling": {
    "behavior": {
      "enabled": false,
      "scaleDown": {},
      "scaleUp": {}
    },
    "customMetrics": [],
    "enabled": false,
    "maxReplicas": 3,
    "minReplicas": 1,
    "targetCPUUtilizationPercentage": 60,
    "targetMemoryUtilizationPercentage": null
  },
  "command": null,
  "dnsConfig": {},
  "extraArgs": [],
  "extraContainers": [],
  "extraEnv": [],
  "extraEnvFrom": [],
  "extraVolumeMounts": [],
  "extraVolumes": [],
  "hostAliases": [],
  "image": {
    "registry": null,
    "repository": null,
    "tag": null
  },
  "initContainers": [],
  "maxSurge": 0,
  "maxUnavailable": null,
  "nodeSelector": {},
  "persistence": {
    "annotations": {},
    "enabled": false,
    "size": "10Gi",
    "storageClass": null
  },
  "podAnnotations": {},
  "podLabels": {},
  "priorityClassName": null,
  "replicas": 0,
  "resources": {},
  "serviceAnnotations": {},
  "serviceLabels": {},
  "terminationGracePeriodSeconds": 30,
  "tolerations": [],
  "topologySpreadConstraints": [
    {
      "labelSelector": {
        "matchLabels": {
          "app.kubernetes.io/component": "querier"
        }
      },
      "maxSkew": 1,
      "topologyKey": "kubernetes.io/hostname",
      "whenUnsatisfiable": "ScheduleAnyway"
    }
  ]
}
querier.affinityobjectAffinity for querier pods.
Hard node anti-affinity
querier.appProtocolobjectAdds the appProtocol field to the querier service. This allows querier to work with istio protocol selection.
{
  "grpc": ""
}
querier.appProtocol.grpcstringSet the optional grpc service protocol. Ex: "grpc", "http2" or "https"
""
querier.autoscaling.behavior.enabledboolEnable autoscaling behaviours
false
querier.autoscaling.behavior.scaleDownobjectdefine scale down policies, must conform to HPAScalingRules
{}
querier.autoscaling.behavior.scaleUpobjectdefine scale up policies, must conform to HPAScalingRules
{}
querier.autoscaling.customMetricslistAllows one to define custom metrics using the HPA/v2 schema (for example, Pods, Object or External metrics)
[]
querier.autoscaling.enabledboolEnable autoscaling for the querier, this is only used if `indexGateway.enabled: true`
false
querier.autoscaling.maxReplicasintMaximum autoscaling replicas for the querier
3
querier.autoscaling.minReplicasintMinimum autoscaling replicas for the querier
1
querier.autoscaling.targetCPUUtilizationPercentageintTarget CPU utilisation percentage for the querier
60
querier.autoscaling.targetMemoryUtilizationPercentagestringTarget memory utilisation percentage for the querier
null
querier.commandstringCommand to execute instead of defined in Docker image
null
querier.dnsConfigobjectDNSConfig for querier pods
{}
querier.extraArgslistAdditional CLI args for the querier
[]
querier.extraContainerslistContainers to add to the querier pods
[]
querier.extraEnvlistEnvironment variables to add to the querier pods
[]
querier.extraEnvFromlistEnvironment variables from secrets or configmaps to add to the querier pods
[]
querier.extraVolumeMountslistVolume mounts to add to the querier pods
[]
querier.extraVolumeslistVolumes to add to the querier pods
[]
querier.hostAliaseslisthostAliases to add
[]
querier.image.registrystringThe Docker registry for the querier image. Overrides `loki.image.registry`
null
querier.image.repositorystringDocker image repository for the querier image. Overrides `loki.image.repository`
null
querier.image.tagstringDocker image tag for the querier image. Overrides `loki.image.tag`
null
querier.initContainerslistInit containers to add to the querier pods
[]
querier.maxSurgeintMax Surge for querier pods
0
querier.maxUnavailablestringPod Disruption Budget maxUnavailable
null
querier.nodeSelectorobjectNode selector for querier pods
{}
querier.persistence.annotationsobjectAnnotations for querier PVCs
{}
querier.persistence.enabledboolEnable creating PVCs for the querier cache
false
querier.persistence.sizestringSize of persistent disk
"10Gi"
querier.persistence.storageClassstringStorage class to be used. If defined, storageClassName: . If set to "-", storageClassName: "", which disables dynamic provisioning. If empty or set to null, no storageClassName spec is set, choosing the default provisioner (gp2 on AWS, standard on GKE, AWS, and OpenStack).
null
querier.podAnnotationsobjectAnnotations for querier pods
{}
querier.podLabelsobjectLabels for querier pods
{}
querier.priorityClassNamestringThe name of the PriorityClass for querier pods
null
querier.replicasintNumber of replicas for the querier
0
querier.resourcesobjectResource requests and limits for the querier
{}
querier.serviceAnnotationsobjectAnnotations for querier service
{}
querier.serviceLabelsobjectLabels for querier service
{}
querier.terminationGracePeriodSecondsintGrace period to allow the querier to shutdown before it is killed
30
querier.tolerationslistTolerations for querier pods
[]
querier.topologySpreadConstraintslisttopologySpread for querier pods.
Defaults to allow skew no more then 1 node
queryFrontendobjectConfiguration for the query-frontend
{
  "affinity": {
    "podAntiAffinity": {
      "requiredDuringSchedulingIgnoredDuringExecution": [
        {
          "labelSelector": {
            "matchLabels": {
              "app.kubernetes.io/component": "query-frontend"
            }
          },
          "topologyKey": "kubernetes.io/hostname"
        }
      ]
    }
  },
  "appProtocol": {
    "grpc": ""
  },
  "autoscaling": {
    "behavior": {
      "enabled": false,
      "scaleDown": {},
      "scaleUp": {}
    },
    "customMetrics": [],
    "enabled": false,
    "maxReplicas": 3,
    "minReplicas": 1,
    "targetCPUUtilizationPercentage": 60,
    "targetMemoryUtilizationPercentage": null
  },
  "command": null,
  "extraArgs": [],
  "extraContainers": [],
  "extraEnv": [],
  "extraEnvFrom": [],
  "extraVolumeMounts": [],
  "extraVolumes": [],
  "hostAliases": [],
  "image": {
    "registry": null,
    "repository": null,
    "tag": null
  },
  "maxUnavailable": null,
  "nodeSelector": {},
  "podAnnotations": {},
  "podLabels": {},
  "priorityClassName": null,
  "replicas": 0,
  "resources": {},
  "serviceAnnotations": {},
  "serviceLabels": {},
  "terminationGracePeriodSeconds": 30,
  "tolerations": []
}
queryFrontend.affinityobjectAffinity for query-frontend pods.
Hard node anti-affinity
queryFrontend.appProtocolobjectAdds the appProtocol field to the queryFrontend service. This allows queryFrontend to work with istio protocol selection.
{
  "grpc": ""
}
queryFrontend.appProtocol.grpcstringSet the optional grpc service protocol. Ex: "grpc", "http2" or "https"
""
queryFrontend.autoscaling.behavior.enabledboolEnable autoscaling behaviours
false
queryFrontend.autoscaling.behavior.scaleDownobjectdefine scale down policies, must conform to HPAScalingRules
{}
queryFrontend.autoscaling.behavior.scaleUpobjectdefine scale up policies, must conform to HPAScalingRules
{}
queryFrontend.autoscaling.customMetricslistAllows one to define custom metrics using the HPA/v2 schema (for example, Pods, Object or External metrics)
[]
queryFrontend.autoscaling.enabledboolEnable autoscaling for the query-frontend
false
queryFrontend.autoscaling.maxReplicasintMaximum autoscaling replicas for the query-frontend
3
queryFrontend.autoscaling.minReplicasintMinimum autoscaling replicas for the query-frontend
1
queryFrontend.autoscaling.targetCPUUtilizationPercentageintTarget CPU utilisation percentage for the query-frontend
60
queryFrontend.autoscaling.targetMemoryUtilizationPercentagestringTarget memory utilisation percentage for the query-frontend
null
queryFrontend.commandstringCommand to execute instead of defined in Docker image
null
queryFrontend.extraArgslistAdditional CLI args for the query-frontend
[]
queryFrontend.extraContainerslistContainers to add to the query-frontend pods
[]
queryFrontend.extraEnvlistEnvironment variables to add to the query-frontend pods
[]
queryFrontend.extraEnvFromlistEnvironment variables from secrets or configmaps to add to the query-frontend pods
[]
queryFrontend.extraVolumeMountslistVolume mounts to add to the query-frontend pods
[]
queryFrontend.extraVolumeslistVolumes to add to the query-frontend pods
[]
queryFrontend.hostAliaseslisthostAliases to add
[]
queryFrontend.image.registrystringThe Docker registry for the query-frontend image. Overrides `loki.image.registry`
null
queryFrontend.image.repositorystringDocker image repository for the query-frontend image. Overrides `loki.image.repository`
null
queryFrontend.image.tagstringDocker image tag for the query-frontend image. Overrides `loki.image.tag`
null
queryFrontend.maxUnavailablestringPod Disruption Budget maxUnavailable
null
queryFrontend.nodeSelectorobjectNode selector for query-frontend pods
{}
queryFrontend.podAnnotationsobjectAnnotations for query-frontend pods
{}
queryFrontend.podLabelsobjectLabels for query-frontend pods
{}
queryFrontend.priorityClassNamestringThe name of the PriorityClass for query-frontend pods
null
queryFrontend.replicasintNumber of replicas for the query-frontend
0
queryFrontend.resourcesobjectResource requests and limits for the query-frontend
{}
queryFrontend.serviceAnnotationsobjectAnnotations for query-frontend service
{}
queryFrontend.serviceLabelsobjectLabels for query-frontend service
{}
queryFrontend.terminationGracePeriodSecondsintGrace period to allow the query-frontend to shutdown before it is killed
30
queryFrontend.tolerationslistTolerations for query-frontend pods
[]
querySchedulerobjectConfiguration for the query-scheduler
{
  "affinity": {
    "podAntiAffinity": {
      "requiredDuringSchedulingIgnoredDuringExecution": [
        {
          "labelSelector": {
            "matchLabels": {
              "app.kubernetes.io/component": "query-scheduler"
            }
          },
          "topologyKey": "kubernetes.io/hostname"
        }
      ]
    }
  },
  "appProtocol": {
    "grpc": ""
  },
  "extraArgs": [],
  "extraContainers": [],
  "extraEnv": [],
  "extraEnvFrom": [],
  "extraVolumeMounts": [],
  "extraVolumes": [],
  "hostAliases": [],
  "image": {
    "registry": null,
    "repository": null,
    "tag": null
  },
  "maxUnavailable": 1,
  "nodeSelector": {},
  "podAnnotations": {},
  "podLabels": {},
  "priorityClassName": null,
  "replicas": 0,
  "resources": {},
  "serviceAnnotations": {},
  "serviceLabels": {},
  "terminationGracePeriodSeconds": 30,
  "tolerations": []
}
queryScheduler.affinityobjectAffinity for query-scheduler pods.
Hard node anti-affinity
queryScheduler.appProtocolobjectSet the optional grpc service protocol. Ex: "grpc", "http2" or "https"
{
  "grpc": ""
}
queryScheduler.extraArgslistAdditional CLI args for the query-scheduler
[]
queryScheduler.extraContainerslistContainers to add to the query-scheduler pods
[]
queryScheduler.extraEnvlistEnvironment variables to add to the query-scheduler pods
[]
queryScheduler.extraEnvFromlistEnvironment variables from secrets or configmaps to add to the query-scheduler pods
[]
queryScheduler.extraVolumeMountslistVolume mounts to add to the query-scheduler pods
[]
queryScheduler.extraVolumeslistVolumes to add to the query-scheduler pods
[]
queryScheduler.hostAliaseslisthostAliases to add
[]
queryScheduler.image.registrystringThe Docker registry for the query-scheduler image. Overrides `loki.image.registry`
null
queryScheduler.image.repositorystringDocker image repository for the query-scheduler image. Overrides `loki.image.repository`
null
queryScheduler.image.tagstringDocker image tag for the query-scheduler image. Overrides `loki.image.tag`
null
queryScheduler.maxUnavailableintPod Disruption Budget maxUnavailable
1
queryScheduler.nodeSelectorobjectNode selector for query-scheduler pods
{}
queryScheduler.podAnnotationsobjectAnnotations for query-scheduler pods
{}
queryScheduler.podLabelsobjectLabels for query-scheduler pods
{}
queryScheduler.priorityClassNamestringThe name of the PriorityClass for query-scheduler pods
null
queryScheduler.replicasintNumber of replicas for the query-scheduler. It should be lower than `-querier.max-concurrent` to avoid generating back-pressure in queriers; it's also recommended that this value evenly divides the latter
0
queryScheduler.resourcesobjectResource requests and limits for the query-scheduler
{}
queryScheduler.serviceAnnotationsobjectAnnotations for query-scheduler service
{}
queryScheduler.serviceLabelsobjectLabels for query-scheduler service
{}
queryScheduler.terminationGracePeriodSecondsintGrace period to allow the query-scheduler to shutdown before it is killed
30
queryScheduler.tolerationslistTolerations for query-scheduler pods
[]
rbac.namespacedboolWhether to install RBAC in the namespace only or cluster-wide. Useful if you want to watch ConfigMap globally.
false
rbac.pspAnnotationsobjectSpecify PSP annotations Ref: https://kubernetes.io/docs/reference/access-authn-authz/psp-to-pod-security-standards/#podsecuritypolicy-annotations
{}
rbac.pspEnabledboolIf pspEnabled true, a PodSecurityPolicy is created for K8s that use psp.
false
rbac.sccEnabledboolFor OpenShift set pspEnabled to 'false' and sccEnabled to 'true' to use the SecurityContextConstraints.
false
readobjectConfiguration for the read pod(s)
{
  "affinity": {
    "podAntiAffinity": {
      "requiredDuringSchedulingIgnoredDuringExecution": [
        {
          "labelSelector": {
            "matchLabels": {
              "app.kubernetes.io/component": "read"
            }
          },
          "topologyKey": "kubernetes.io/hostname"
        }
      ]
    }
  },
  "annotations": {},
  "autoscaling": {
    "behavior": {},
    "enabled": false,
    "maxReplicas": 6,
    "minReplicas": 2,
    "targetCPUUtilizationPercentage": 60,
    "targetMemoryUtilizationPercentage": null
  },
  "dnsConfig": {},
  "extraArgs": [],
  "extraContainers": [],
  "extraEnv": [],
  "extraEnvFrom": [],
  "extraVolumeMounts": [],
  "extraVolumes": [],
  "image": {
    "registry": null,
    "repository": null,
    "tag": null
  },
  "legacyReadTarget": false,
  "lifecycle": {},
  "nodeSelector": {},
  "persistence": {
    "annotations": {},
    "enableStatefulSetAutoDeletePVC": true,
    "selector": null,
    "size": "10Gi",
    "storageClass": null
  },
  "podAnnotations": {},
  "podLabels": {},
  "podManagementPolicy": "Parallel",
  "priorityClassName": null,
  "replicas": 3,
  "resources": {},
  "selectorLabels": {},
  "service": {
    "annotations": {},
    "labels": {}
  },
  "targetModule": "read",
  "terminationGracePeriodSeconds": 30,
  "tolerations": [],
  "topologySpreadConstraints": []
}
read.affinityobjectAffinity for read pods.
Hard node anti-affinity
read.annotationsobjectAnnotations for read deployment
{}
read.autoscaling.behaviorobjectBehavior policies while scaling.
{}
read.autoscaling.enabledboolEnable autoscaling for the read, this is only used if `queryIndex.enabled: true`
false
read.autoscaling.maxReplicasintMaximum autoscaling replicas for the read
6
read.autoscaling.minReplicasintMinimum autoscaling replicas for the read
2
read.autoscaling.targetCPUUtilizationPercentageintTarget CPU utilisation percentage for the read
60
read.autoscaling.targetMemoryUtilizationPercentagestringTarget memory utilisation percentage for the read
null
read.dnsConfigobjectDNS config for read pods
{}
read.extraArgslistAdditional CLI args for the read
[]
read.extraContainerslistContainers to add to the read pods
[]
read.extraEnvlistEnvironment variables to add to the read pods
[]
read.extraEnvFromlistEnvironment variables from secrets or configmaps to add to the read pods
[]
read.extraVolumeMountslistVolume mounts to add to the read pods
[]
read.extraVolumeslistVolumes to add to the read pods
[]
read.image.registrystringThe Docker registry for the read image. Overrides `loki.image.registry`
null
read.image.repositorystringDocker image repository for the read image. Overrides `loki.image.repository`
null
read.image.tagstringDocker image tag for the read image. Overrides `loki.image.tag`
null
read.legacyReadTargetboolWhether or not to use the 2 target type simple scalable mode (read, write) or the 3 target type (read, write, backend). Legacy refers to the 2 target type, so true will run two targets, false will run 3 targets.
false
read.lifecycleobjectLifecycle for the read container
{}
read.nodeSelectorobjectNode selector for read pods
{}
read.persistence.annotationsobjectAnnotations for volume claim
{}
read.persistence.enableStatefulSetAutoDeletePVCboolEnable StatefulSetAutoDeletePVC feature
true
read.persistence.selectorstringSelector for persistent disk
null
read.persistence.sizestringSize of persistent disk
"10Gi"
read.persistence.storageClassstringStorage class to be used. If defined, storageClassName: . If set to "-", storageClassName: "", which disables dynamic provisioning. If empty or set to null, no storageClassName spec is set, choosing the default provisioner (gp2 on AWS, standard on GKE, AWS, and OpenStack).
null
read.podAnnotationsobjectAnnotations for read pods
{}
read.podLabelsobjectAdditional labels for each `read` pod
{}
read.podManagementPolicystringThe default is to deploy all pods in parallel.
"Parallel"
read.priorityClassNamestringThe name of the PriorityClass for read pods
null
read.replicasintNumber of replicas for the read
3
read.resourcesobjectResource requests and limits for the read
{}
read.selectorLabelsobjectAdditional selector labels for each `read` pod
{}
read.service.annotationsobjectAnnotations for read Service
{}
read.service.labelsobjectAdditional labels for read Service
{}
read.targetModulestringComma-separated list of Loki modules to load for the read
"read"
read.terminationGracePeriodSecondsintGrace period to allow the read to shutdown before it is killed
30
read.tolerationslistTolerations for read pods
[]
read.topologySpreadConstraintslistTopology Spread Constraints for read pods
[]
resultsCache.affinityobjectAffinity for results-cache pods
{}
resultsCache.allocatedMemoryintAmount of memory allocated to results-cache for object storage (in MB).
1024
resultsCache.annotationsobjectAnnotations for the results-cache pods
{}
resultsCache.connectionLimitintMaximum number of connections allowed
16384
resultsCache.defaultValiditystringSpecify how long cached results should be stored in the results-cache before being expired
"12h"
resultsCache.enabledboolSpecifies whether memcached based results-cache should be enabled
true
resultsCache.extraArgsobjectAdditional CLI args for results-cache
{}
resultsCache.extraContainerslistAdditional containers to be added to the results-cache pod.
[]
resultsCache.extraExtendedOptionsstringAdd extended options for results-cache memcached container. The format is the same as for the memcached -o/--extend flag. Example: extraExtendedOptions: 'tls,modern,track_sizes'
""
resultsCache.extraVolumeMountslistAdditional volume mounts to be added to the results-cache pod (applies to both memcached and exporter containers). Example: extraVolumeMounts: - name: extra-volume mountPath: /etc/extra-volume readOnly: true
[]
resultsCache.extraVolumeslistAdditional volumes to be added to the results-cache pod (applies to both memcached and exporter containers). Example: extraVolumes: - name: extra-volume secret: secretName: extra-volume-secret
[]
resultsCache.initContainerslistExtra init containers for results-cache pods
[]
resultsCache.maxItemMemoryintMaximum item results-cache for memcached (in MB).
5
resultsCache.nodeSelectorobjectNode selector for results-cache pods
{}
resultsCache.persistenceobjectPersistence settings for the results-cache
{
  "enabled": false,
  "mountPath": "/data",
  "storageClass": null,
  "storageSize": "10G"
}
resultsCache.persistence.enabledboolEnable creating PVCs for the results-cache
false
resultsCache.persistence.mountPathstringVolume mount path
"/data"
resultsCache.persistence.storageClassstringStorage class to be used. If defined, storageClassName: . If set to "-", storageClassName: "", which disables dynamic provisioning. If empty or set to null, no storageClassName spec is set, choosing the default provisioner (gp2 on AWS, standard on GKE, AWS, and OpenStack).
null
resultsCache.persistence.storageSizestringSize of persistent disk, must be in G or Gi
"10G"
resultsCache.podAnnotationsobjectAnnotations for results-cache pods
{}
resultsCache.podDisruptionBudgetobjectPod Disruption Budget
{
  "maxUnavailable": 1
}
resultsCache.podLabelsobjectLabels for results-cache pods
{}
resultsCache.podManagementPolicystringManagement policy for results-cache pods
"Parallel"
resultsCache.portintPort of the results-cache service
11211
resultsCache.priorityClassNamestringThe name of the PriorityClass for results-cache pods
null
resultsCache.replicasintTotal number of results-cache replicas
1
resultsCache.resourcesstringResource requests and limits for the results-cache By default a safe memory limit will be requested based on allocatedMemory value (floor (* 1.2 allocatedMemory)).
null
resultsCache.serviceobjectService annotations and labels
{
  "annotations": {},
  "labels": {}
}
resultsCache.statefulStrategyobjectStateful results-cache strategy
{
  "type": "RollingUpdate"
}
resultsCache.terminationGracePeriodSecondsintGrace period to allow the results-cache to shutdown before it is killed
60
resultsCache.timeoutstringMemcached operation timeout
"500ms"
resultsCache.tolerationslistTolerations for results-cache pods
[]
resultsCache.topologySpreadConstraintslisttopologySpreadConstraints allows to customize the default topologySpreadConstraints. This can be either a single dict as shown below or a slice of topologySpreadConstraints. labelSelector is taken from the constraint itself (if it exists) or is generated by the chart using the same selectors as for services.
[]
resultsCache.writebackBufferintMax number of objects to use for cache write back
500000
resultsCache.writebackParallelismintNumber of parallel threads for cache write back
1
resultsCache.writebackSizeLimitstringMax memory to use for cache write back
"500MB"
rollout_operatorobjectSetting for the Grafana Rollout Operator https://github.com/grafana/helm-charts/tree/main/charts/rollout-operator
{
  "enabled": false,
  "podSecurityContext": {
    "fsGroup": 10001,
    "runAsGroup": 10001,
    "runAsNonRoot": true,
    "runAsUser": 10001,
    "seccompProfile": {
      "type": "RuntimeDefault"
    }
  },
  "securityContext": {
    "allowPrivilegeEscalation": false,
    "capabilities": {
      "drop": [
        "ALL"
      ]
    },
    "readOnlyRootFilesystem": true
  }
}
rollout_operator.podSecurityContextobjectpodSecurityContext is the pod security context for the rollout operator. When installing on OpenShift, override podSecurityContext settings with rollout_operator: podSecurityContext: fsGroup: null runAsGroup: null runAsUser: null
{
  "fsGroup": 10001,
  "runAsGroup": 10001,
  "runAsNonRoot": true,
  "runAsUser": 10001,
  "seccompProfile": {
    "type": "RuntimeDefault"
  }
}
rulerobjectConfiguration for the ruler
{
  "affinity": {
    "podAntiAffinity": {
      "requiredDuringSchedulingIgnoredDuringExecution": [
        {
          "labelSelector": {
            "matchLabels": {
              "app.kubernetes.io/component": "ruler"
            }
          },
          "topologyKey": "kubernetes.io/hostname"
        }
      ]
    }
  },
  "appProtocol": {
    "grpc": ""
  },
  "command": null,
  "directories": {},
  "dnsConfig": {},
  "enabled": true,
  "extraArgs": [],
  "extraContainers": [],
  "extraEnv": [],
  "extraEnvFrom": [],
  "extraVolumeMounts": [],
  "extraVolumes": [],
  "hostAliases": [],
  "image": {
    "registry": null,
    "repository": null,
    "tag": null
  },
  "initContainers": [],
  "maxUnavailable": null,
  "nodeSelector": {},
  "persistence": {
    "annotations": {},
    "enabled": false,
    "size": "10Gi",
    "storageClass": null
  },
  "podAnnotations": {},
  "podLabels": {},
  "priorityClassName": null,
  "replicas": 0,
  "resources": {},
  "serviceAnnotations": {},
  "serviceLabels": {},
  "terminationGracePeriodSeconds": 300,
  "tolerations": []
}
ruler.affinityobjectAffinity for ruler pods.
Hard node anti-affinity
ruler.appProtocolobjectSet the optional grpc service protocol. Ex: "grpc", "http2" or "https"
{
  "grpc": ""
}
ruler.commandstringCommand to execute instead of defined in Docker image
null
ruler.directoriesobjectDirectories containing rules files
{}
ruler.dnsConfigobjectDNSConfig for ruler pods
{}
ruler.enabledboolThe ruler component is optional and can be disabled if desired.
true
ruler.extraArgslistAdditional CLI args for the ruler
[]
ruler.extraContainerslistContainers to add to the ruler pods
[]
ruler.extraEnvlistEnvironment variables to add to the ruler pods
[]
ruler.extraEnvFromlistEnvironment variables from secrets or configmaps to add to the ruler pods
[]
ruler.extraVolumeMountslistVolume mounts to add to the ruler pods
[]
ruler.extraVolumeslistVolumes to add to the ruler pods
[]
ruler.hostAliaseslisthostAliases to add
[]
ruler.image.registrystringThe Docker registry for the ruler image. Overrides `loki.image.registry`
null
ruler.image.repositorystringDocker image repository for the ruler image. Overrides `loki.image.repository`
null
ruler.image.tagstringDocker image tag for the ruler image. Overrides `loki.image.tag`
null
ruler.initContainerslistInit containers to add to the ruler pods
[]
ruler.maxUnavailablestringPod Disruption Budget maxUnavailable
null
ruler.nodeSelectorobjectNode selector for ruler pods
{}
ruler.persistence.annotationsobjectAnnotations for ruler PVCs
{}
ruler.persistence.enabledboolEnable creating PVCs which is required when using recording rules
false
ruler.persistence.sizestringSize of persistent disk
"10Gi"
ruler.persistence.storageClassstringStorage class to be used. If defined, storageClassName: . If set to "-", storageClassName: "", which disables dynamic provisioning. If empty or set to null, no storageClassName spec is set, choosing the default provisioner (gp2 on AWS, standard on GKE, AWS, and OpenStack).
null
ruler.podAnnotationsobjectAnnotations for ruler pods
{}
ruler.podLabelsobjectLabels for compactor pods
{}
ruler.priorityClassNamestringThe name of the PriorityClass for ruler pods
null
ruler.replicasintNumber of replicas for the ruler
0
ruler.resourcesobjectResource requests and limits for the ruler
{}
ruler.serviceAnnotationsobjectAnnotations for ruler service
{}
ruler.serviceLabelsobjectLabels for ruler service
{}
ruler.terminationGracePeriodSecondsintGrace period to allow the ruler to shutdown before it is killed
300
ruler.tolerationslistTolerations for ruler pods
[]
serviceAccount.annotationsobjectAnnotations for the service account
{}
serviceAccount.automountServiceAccountTokenboolSet this toggle to false to opt out of automounting API credentials for the service account
true
serviceAccount.createboolSpecifies whether a ServiceAccount should be created
true
serviceAccount.imagePullSecretslistImage pull secrets for the service account
[]
serviceAccount.labelsobjectLabels for the service account
{}
serviceAccount.namestringThe name of the ServiceAccount to use. If not set and create is true, a name is generated using the fullname template
null
sidecar.enableUniqueFilenamesboolEnsure that rule files aren't conflicting and being overwritten by prefixing their name with the namespace they are defined in.
false
sidecar.image.pullPolicystringDocker image pull policy
"IfNotPresent"
sidecar.image.repositorystringThe Docker registry and image for the k8s sidecar
"kiwigrid/k8s-sidecar"
sidecar.image.shastringDocker image sha. If empty, no sha will be used
""
sidecar.image.tagstringDocker image tag
"1.27.5"
sidecar.livenessProbeobjectLiveness probe definition. Probe is disabled on the sidecar by default.
{}
sidecar.readinessProbeobjectReadiness probe definition. Probe is disabled on the sidecar by default.
{}
sidecar.resourcesobjectResource requests and limits for the sidecar
{}
sidecar.rules.enabledboolWhether or not to create a sidecar to ingest rule from specific ConfigMaps and/or Secrets.
true
sidecar.rules.folderstringFolder into which the rules will be placed.
"/rules"
sidecar.rules.labelstringLabel that the configmaps/secrets with rules will be marked with.
"loki_rule"
sidecar.rules.labelValuestringLabel value that the configmaps/secrets with rules will be set to.
""
sidecar.rules.logLevelstringLog level of the sidecar container.
"INFO"
sidecar.rules.resourcestringSearch in configmap, secret, or both.
"both"
sidecar.rules.scriptstringAbsolute path to the shell script to execute after a configmap or secret has been reloaded.
null
sidecar.rules.searchNamespacestringComma separated list of namespaces. If specified, the sidecar will search for config-maps/secrets inside these namespaces. Otherwise the namespace in which the sidecar is running will be used. It's also possible to specify 'ALL' to search in all namespaces.
null
sidecar.rules.watchClientTimeoutintWatchClientTimeout: is a client-side timeout, configuring your local socket. If you have a network outage dropping all packets with no RST/FIN, this is how long your client waits before realizing & dropping the connection. Defaults to 66sec.
60
sidecar.rules.watchMethodstringMethod to use to detect ConfigMap changes. With WATCH the sidecar will do a WATCH request, with SLEEP it will list all ConfigMaps, then sleep for 60 seconds.
"WATCH"
sidecar.rules.watchServerTimeoutintWatchServerTimeout: request to the server, asking it to cleanly close the connection after that. defaults to 60sec; much higher values like 3600 seconds (1h) are feasible for non-Azure K8S.
60
sidecar.securityContextobjectThe SecurityContext for the sidecar.
{}
sidecar.skipTlsVerifyboolSet to true to skip tls verification for kube api calls.
false
singleBinary.affinityobjectAffinity for single binary pods.
Hard node anti-affinity
singleBinary.annotationsobjectAnnotations for single binary StatefulSet
{}
singleBinary.autoscaling.enabledboolEnable autoscaling
false
singleBinary.autoscaling.maxReplicasintMaximum autoscaling replicas for the single binary
3
singleBinary.autoscaling.minReplicasintMinimum autoscaling replicas for the single binary
1
singleBinary.autoscaling.targetCPUUtilizationPercentageintTarget CPU utilisation percentage for the single binary
60
singleBinary.autoscaling.targetMemoryUtilizationPercentagestringTarget memory utilisation percentage for the single binary
null
singleBinary.dnsConfigobjectDNS config for single binary pods
{}
singleBinary.extraArgslistLabels for single binary service
[]
singleBinary.extraContainerslistExtra containers to add to the single binary loki pod
[]
singleBinary.extraEnvlistEnvironment variables to add to the single binary pods
[]
singleBinary.extraEnvFromlistEnvironment variables from secrets or configmaps to add to the single binary pods
[]
singleBinary.extraVolumeMountslistVolume mounts to add to the single binary pods
[]
singleBinary.extraVolumeslistVolumes to add to the single binary pods
[]
singleBinary.image.registrystringThe Docker registry for the single binary image. Overrides `loki.image.registry`
null
singleBinary.image.repositorystringDocker image repository for the single binary image. Overrides `loki.image.repository`
null
singleBinary.image.tagstringDocker image tag for the single binary image. Overrides `loki.image.tag`
null
singleBinary.initContainerslistInit containers to add to the single binary pods
[]
singleBinary.nodeSelectorobjectNode selector for single binary pods
{}
singleBinary.persistence.annotationsobjectAnnotations for volume claim
{}
singleBinary.persistence.enableStatefulSetAutoDeletePVCboolEnable StatefulSetAutoDeletePVC feature
true
singleBinary.persistence.enabledboolEnable persistent disk
true
singleBinary.persistence.selectorstringSelector for persistent disk
null
singleBinary.persistence.sizestringSize of persistent disk
"10Gi"
singleBinary.persistence.storageClassstringStorage class to be used. If defined, storageClassName: . If set to "-", storageClassName: "", which disables dynamic provisioning. If empty or set to null, no storageClassName spec is set, choosing the default provisioner (gp2 on AWS, standard on GKE, AWS, and OpenStack).
null
singleBinary.podAnnotationsobjectAnnotations for single binary pods
{}
singleBinary.podLabelsobjectAdditional labels for each `single binary` pod
{}
singleBinary.priorityClassNamestringThe name of the PriorityClass for single binary pods
null
singleBinary.replicasintNumber of replicas for the single binary
0
singleBinary.resourcesobjectResource requests and limits for the single binary
{}
singleBinary.selectorLabelsobjectAdditional selector labels for each `single binary` pod
{}
singleBinary.service.annotationsobjectAnnotations for single binary Service
{}
singleBinary.service.labelsobjectAdditional labels for single binary Service
{}
singleBinary.targetModulestringComma-separated list of Loki modules to load for the single binary
"all"
singleBinary.terminationGracePeriodSecondsintGrace period to allow the single binary to shutdown before it is killed
30
singleBinary.tolerationslistTolerations for single binary pods
[]
tableManagerobjectDEPRECATED Configuration for the table-manager. The table-manager is only necessary when using a deprecated index type such as Cassandra, Bigtable, or DynamoDB, it has not been necessary since loki introduced self- contained index types like 'boltdb-shipper' and 'tsdb'. This will be removed in a future helm chart.
{
  "affinity": {
    "podAntiAffinity": {
      "requiredDuringSchedulingIgnoredDuringExecution": [
        {
          "labelSelector": {
            "matchLabels": {
              "app.kubernetes.io/component": "table-manager"
            }
          },
          "topologyKey": "kubernetes.io/hostname"
        }
      ]
    }
  },
  "annotations": {},
  "command": null,
  "dnsConfig": {},
  "enabled": false,
  "extraArgs": [],
  "extraContainers": [],
  "extraEnv": [],
  "extraEnvFrom": [],
  "extraVolumeMounts": [],
  "extraVolumes": [],
  "image": {
    "registry": null,
    "repository": null,
    "tag": null
  },
  "nodeSelector": {},
  "podAnnotations": {},
  "podLabels": {},
  "priorityClassName": null,
  "resources": {},
  "retention_deletes_enabled": false,
  "retention_period": 0,
  "service": {
    "annotations": {},
    "labels": {}
  },
  "terminationGracePeriodSeconds": 30,
  "tolerations": []
}
tableManager.affinityobjectAffinity for table-manager pods.
Hard node and anti-affinity
tableManager.annotationsobjectAnnotations for table-manager deployment
{}
tableManager.commandstringCommand to execute instead of defined in Docker image
null
tableManager.dnsConfigobjectDNS config table-manager pods
{}
tableManager.enabledboolSpecifies whether the table-manager should be enabled
false
tableManager.extraArgslistAdditional CLI args for the table-manager
[]
tableManager.extraContainerslistContainers to add to the table-manager pods
[]
tableManager.extraEnvlistEnvironment variables to add to the table-manager pods
[]
tableManager.extraEnvFromlistEnvironment variables from secrets or configmaps to add to the table-manager pods
[]
tableManager.extraVolumeMountslistVolume mounts to add to the table-manager pods
[]
tableManager.extraVolumeslistVolumes to add to the table-manager pods
[]
tableManager.image.registrystringThe Docker registry for the table-manager image. Overrides `loki.image.registry`
null
tableManager.image.repositorystringDocker image repository for the table-manager image. Overrides `loki.image.repository`
null
tableManager.image.tagstringDocker image tag for the table-manager image. Overrides `loki.image.tag`
null
tableManager.nodeSelectorobjectNode selector for table-manager pods
{}
tableManager.podAnnotationsobjectAnnotations for table-manager pods
{}
tableManager.podLabelsobjectLabels for table-manager pods
{}
tableManager.priorityClassNamestringThe name of the PriorityClass for table-manager pods
null
tableManager.resourcesobjectResource requests and limits for the table-manager
{}
tableManager.retention_deletes_enabledboolEnable deletes by retention
false
tableManager.retention_periodintSet retention period
0
tableManager.service.annotationsobjectAnnotations for table-manager Service
{}
tableManager.service.labelsobjectAdditional labels for table-manager Service
{}
tableManager.terminationGracePeriodSecondsintGrace period to allow the table-manager to shutdown before it is killed
30
tableManager.tolerationslistTolerations for table-manager pods
[]
testobjectSection for configuring optional Helm test
{
  "annotations": {},
  "canaryServiceAddress": "http://loki-canary:3500/metrics",
  "enabled": true,
  "image": {
    "digest": null,
    "pullPolicy": "IfNotPresent",
    "registry": "docker.io",
    "repository": "grafana/loki-helm-test",
    "tag": "ewelch-distributed-helm-chart-17db5ee"
  },
  "labels": {},
  "prometheusAddress": "",
  "timeout": "1m"
}
test.annotationsobjectAdditional annotations for test pods
{}
test.canaryServiceAddressstringUsed to directly query the metrics endpoint of the canary for testing, this approach avoids needing prometheus for testing. This in a newer approach to using prometheusAddress such that tests do not have a dependency on prometheus
"http://loki-canary:3500/metrics"
test.imageobjectImage to use for loki canary
{
  "digest": null,
  "pullPolicy": "IfNotPresent",
  "registry": "docker.io",
  "repository": "grafana/loki-helm-test",
  "tag": "ewelch-distributed-helm-chart-17db5ee"
}
test.image.digeststringOverrides the image tag with an image digest
null
test.image.pullPolicystringDocker image pull policy
"IfNotPresent"
test.image.registrystringThe Docker registry
"docker.io"
test.image.repositorystringDocker image repository
"grafana/loki-helm-test"
test.image.tagstringOverrides the image tag whose default is the chart's appVersion
"ewelch-distributed-helm-chart-17db5ee"
test.labelsobjectAdditional labels for the test pods
{}
test.prometheusAddressstringAddress of the prometheus server to query for the test. This overrides any value set for canaryServiceAddress. This is kept for backward compatibility and may be removed in future releases. Previous value was 'http://prometheus:9090'
""
test.timeoutstringNumber of times to retry the test before failing
"1m"
write.affinityobjectAffinity for write pods.
Hard node anti-affinity
write.annotationsobjectAnnotations for write StatefulSet
{}
write.autoscaling.behaviorobjectBehavior policies while scaling.
{
  "scaleDown": {
    "policies": [
      {
        "periodSeconds": 1800,
        "type": "Pods",
        "value": 1
      }
    ],
    "stabilizationWindowSeconds": 3600
  },
  "scaleUp": {
    "policies": [
      {
        "periodSeconds": 900,
        "type": "Pods",
        "value": 1
      }
    ]
  }
}
write.autoscaling.behavior.scaleUpobjectsee https://github.com/grafana/loki/blob/main/docs/sources/operations/storage/wal.md#how-to-scale-updown for scaledown details
{
  "policies": [
    {
      "periodSeconds": 900,
      "type": "Pods",
      "value": 1
    }
  ]
}
write.autoscaling.enabledboolEnable autoscaling for the write.
false
write.autoscaling.maxReplicasintMaximum autoscaling replicas for the write.
6
write.autoscaling.minReplicasintMinimum autoscaling replicas for the write.
2
write.autoscaling.targetCPUUtilizationPercentageintTarget CPU utilisation percentage for the write.
60
write.autoscaling.targetMemoryUtilizationPercentagestringTarget memory utilization percentage for the write.
null
write.dnsConfigobjectDNS config for write pods
{}
write.extraArgslistAdditional CLI args for the write
[]
write.extraContainerslistContainers to add to the write pods
[]
write.extraEnvlistEnvironment variables to add to the write pods
[]
write.extraEnvFromlistEnvironment variables from secrets or configmaps to add to the write pods
[]
write.extraVolumeClaimTemplateslistvolumeClaimTemplates to add to StatefulSet
[]
write.extraVolumeMountslistVolume mounts to add to the write pods
[]
write.extraVolumeslistVolumes to add to the write pods
[]
write.image.registrystringThe Docker registry for the write image. Overrides `loki.image.registry`
null
write.image.repositorystringDocker image repository for the write image. Overrides `loki.image.repository`
null
write.image.tagstringDocker image tag for the write image. Overrides `loki.image.tag`
null
write.initContainerslistInit containers to add to the write pods
[]
write.lifecycleobjectLifecycle for the write container
{}
write.nodeSelectorobjectNode selector for write pods
{}
write.persistence.annotationsobjectAnnotations for volume claim
{}
write.persistence.dataVolumeParametersobjectParameters used for the `data` volume when volumeClaimEnabled if false
{
  "emptyDir": {}
}
write.persistence.enableStatefulSetAutoDeletePVCboolEnable StatefulSetAutoDeletePVC feature
false
write.persistence.selectorstringSelector for persistent disk
null
write.persistence.sizestringSize of persistent disk
"10Gi"
write.persistence.storageClassstringStorage class to be used. If defined, storageClassName: . If set to "-", storageClassName: "", which disables dynamic provisioning. If empty or set to null, no storageClassName spec is set, choosing the default provisioner (gp2 on AWS, standard on GKE, AWS, and OpenStack).
null
write.persistence.volumeClaimsEnabledboolEnable volume claims in pod spec
true
write.podAnnotationsobjectAnnotations for write pods
{}
write.podLabelsobjectAdditional labels for each `write` pod
{}
write.podManagementPolicystringThe default is to deploy all pods in parallel.
"Parallel"
write.priorityClassNamestringThe name of the PriorityClass for write pods
null
write.replicasintNumber of replicas for the write
3
write.resourcesobjectResource requests and limits for the write
{}
write.selectorLabelsobjectAdditional selector labels for each `write` pod
{}
write.service.annotationsobjectAnnotations for write Service
{}
write.service.labelsobjectAdditional labels for write Service
{}
write.targetModulestringComma-separated list of Loki modules to load for the write
"write"
write.terminationGracePeriodSecondsintGrace period to allow the write to shutdown before it is killed. Especially for the ingester, this must be increased. It must be long enough so writes can be gracefully shutdown flushing/transferring all data and to successfully leave the member ring on shutdown.
300
write.tolerationslistTolerations for write pods
[]
write.topologySpreadConstraintslistTopology Spread Constraints for write pods
[]