Why a Loki 2.x to 3.0 upgrade needs a plan before the cutover
A Loki 2.x to 3.0 upgrade is a planned migration, and the cutover should be scheduled only after the plan is written and tested. The upgrade touches the index, the schema, the object storage that holds compressed chunks and the configuration file, so a change in one area can stop ingestion or break queries in another. If your team runs Loki 2.x today and must keep logs flowing and searchable through the change, the work is less about swapping binaries and more about sequencing changes that depend on each other. The reasons to upgrade are the ones that usually drive a major release: a newer index and schema design, continued vendor development, and staying on a line that still receives fixes. The supported path runs through the official upgrade guide, which sets out the version steps and the schema and storage changes you must make in order. Do not treat any step as settled from memory or from a blog post. Confirm each version step, each schema setting and each configuration change against the official 3.0 upgrade guide and the release notes for every version in between, and record which source you used for each decision.
Log shipping is the part of the upgrade that teams most often leave until the end. Promtail reached end of life on March 2, 2026, so it receives no further updates or commercial support, and Grafana directs Promtail users to migrate to Grafana Alloy. If your agents still run Promtail, the upgrade is the natural point to decide whether Alloy replaces it in the same change window or in a separate one. Alloy is Grafana's supported log shipper for Loki, and it can be rolled out host by host while the old pipeline keeps running. Write down which hosts, containers and applications send logs through which agent before you change anything. Another early check is the deployment mode. Loki documents monolithic, simple scalable and microservices modes, and the documentation states that simple scalable mode is being deprecated and will be removed in the Loki 4.0 release. If you run simple scalable mode, the 3.0 upgrade does not remove the need to plan for 4.0. Decide now whether you will move to another supported mode, and ask your team to confirm that choice in writing before the 3.0 cutover is scheduled.
The plan should also list what depends on Loki. Inventory the tenants and the X-Scope-OrgID headers in use when multi-tenancy is enabled, the retention rules in the compactor, the Grafana data sources and dashboards that query Loki, and the alerting rules that depend on log queries. Each of these can change behavior after an upgrade, and each has an owner who must sign off. Retention is disabled by default, so confirm whether retention_enabled is set in your environment and whether any per-tenant or per-stream rules exist, because a retention change during an upgrade can remove data that someone still needs. Finally, define the rollback path before the window opens. Specify which backups or snapshots you will take, how long the old configuration will remain available, who makes the go or no-go call, and which queries and ingestion tests must pass before the old version is retired. Ask whoever will perform the work to show the test environment results and the change steps, and to name the release notes they checked for each setting they changed. A written plan with these owners and checks is what turns the cutover into a controlled event.
What changes between Loki 2.x and 3.0, and what each change requires
This table lists the main changes between Loki 2.x and 3.0, the operational impact of each, and the action your team needs to take. It works as a planning checklist, and the release notes for 3.0 were not supplied to us, so confirm exact field names, values and version notes in the official upgrade guide before acting on any row. The main takeaway is that schema, metadata and limit changes can alter ingestion and query results without an obvious error, so each one needs a test before cutover.
| Change | Impact | Action needed |
|---|---|---|
| Index moves to TSDB and schema v13 | Index and schema settings change how chunks and index entries are read and written. Mismatched period config can cause query gaps. | Confirm the schema version, period config and migration steps in the 3.0 upgrade guide. Test queries on a staging copy first. |
| Structured metadata | Metadata attached to log lines may be stored and queried differently, and ingestion behavior for it may change. | Confirm the enablement setting and related limits in the upgrade guide. Check that dashboards and saved queries still return expected results. |
| Removed shipper settings | Config files that still set removed shipper options may fail to load at startup, stopping the component. | Search all configs for removed shipper keys. Confirm replacements in the upgrade guide and validate each file in staging before rollout. |
| New default limits that can reject logs | Streams or lines above the new defaults can be rejected at ingestion, leaving silent gaps in log data. | Compare current overrides with the new defaults. Confirm values in the guide, set explicit limits where needed, and watch rejection metrics after cutover. |
| Simple scalable mode removed in 4.0 | Loki documentation states simple scalable mode is deprecated and will be removed with 4.0. Deployments on it will need a move to another mode. | Choose a target mode, monolithic or microservices, before 4.0 is planned. Confirm version notes and migration steps in the official docs. |
How your deployment mode changes the 3.0 upgrade work
Your deployment mode determines how many moving parts the 3.0 upgrade touches, so confirm it before anyone estimates the work. Loki documents three modes. Monolithic runs as a single binary and is documented for up to about 20 GB of logs per day. Simple scalable mode separates read, write and backend targets and is documented as approaching 1 TB per day. Microservices mode is intended for very large clusters, where each component is deployed and scaled on its own. Each mode has its own configuration, scaling settings and order of component changes, so a plan written for one mode rarely transfers to another.
In monolithic mode, the upgrade centers on one process. You change the binary version, update the configuration for the new storage and schema settings, and restart inside a planned window. The work is concentrated and easier to reason about, but rollback is only practical if you have kept the prior configuration and tested the path back to it. Simple scalable and microservices deployments multiply that work. Every target or component needs consistent configuration, and the order of changes matters because writers and readers must agree on the new format. Confirm the exact sequence for your version pair in the official upgrade guide before you rely on any summary, including this one.
If you run simple scalable mode, treat the 3.0 upgrade as the first of two migrations. Loki's documentation states that simple scalable deployment is being deprecated and will be removed with the Loki 4.0 release. Staying on it through 3.0 means the decision you still owe is where you go next: a supported mode chosen for your volume, or microservices. Ask whether the target layout can be designed and tested alongside the 3.0 change so the second move does not repeat the first. Record the decision with an owner and a review date, and confirm the 4.0 timing in the current Loki release notes.
Before estimating, gather three facts: the deployment mode as it appears in your Helm values or process manifests, your average and peak daily ingest volume from ingestion metrics over a representative period, and the number of tenants and stream labels in use. Volume matters because it shows whether monolithic mode still fits and how much compaction and query load the upgrade window must absorb. Ask any partner to base the estimate on these numbers, to list the components in scope, and to state what is excluded, such as log shipper changes, which are separate work.
Back up, inventory and test before you change the schema
Schema changes in the Loki 2.x to 3.0 upgrade are hard to reverse once data is written in the new format. The cards below cover the backup, configuration, inventory and test work that should be finished and signed off before anyone changes the schema in production.
Full object storage backup
Take a complete backup of the bucket that holds Loki's compressed chunks and index before the upgrade starts. Platform or storage engineers usually own this, and they should confirm the backup can be restored into a separate bucket. Check the official upgrade guide for any step that changes how chunks or index objects are laid out, because that determines what a rollback can recover.
Current configuration and runtime overrides
Copy the running Loki configuration file and any runtime overrides file, then store both in version control with the deployment date. Platform engineers typically own this step. Confirm which settings the 3.0 release removes or renames, including shipper settings, and record which values are set explicitly so defaults that changed are not applied unnoticed.
Tenants, retention and limits inventory
List every tenant ID, its retention rules and its per-tenant limits, and note which tenants send logs through the X-Scope-OrgID header. Observability leads usually own this list, with input from application owners. Confirm the new default limits in the 3.0 guide, since limits that were not set before can start rejecting logs for tenants that previously ingested without problems.
Log shipper and version list
Record every agent or pipeline that sends logs to Loki, with its name, version and host group. Platform or security operations teams usually own this inventory. Flag Promtail installations, since Promtail reached end of life on March 2, 2026, and plan their move to Grafana Alloy. Confirm each shipper's compatibility with the target Loki release in the vendor documentation.
Dashboards and alert rules that query Loki
Export a list of every dashboard panel and alert rule that uses a Loki data source, including the LogQL queries and the owning team. Observability engineers or on-call leads usually own this inventory. Queries that depend on labels, structured metadata or retention windows may behave differently after the schema change, so each one should be tested against the upgraded environment before cutover.
Test environment with production data
Build a test environment that matches production configuration and includes representative log volume and tenant mix, ideally restored from the backup. Platform engineering or QA usually owns it. Run the full upgrade there first, verify ingestion, queries and retention, and confirm the schema migration steps in the official guide before scheduling the production window.
The Loki 2.x to 3.0 upgrade sequence with checks and rollback points
This sequence moves a Loki 2.x deployment to 3.0 in an order that protects stored log data. Each step closes with a check your team can record, and marked rollback points show where restoring from backup or reverting the binary is still safe. Exact commands and configuration keys come from the official upgrade guide, which governs the work at every step.
Freeze changes and capture a verified baseline
Your team, or DeployOpen under a written scope, stops unrelated changes to Loki configuration, Grafana data sources and the object storage buckets for the length of the upgrade. Record the running version, the configuration files, the index and schema settings in use, the active limits and the retention settings. Then take a backup of the object storage and the configuration. Check: a test restore of the backup into a scratch location succeeds, and the recorded baseline matches the live cluster. Rollback point: until a new binary touches the index or schema, restoring the backup and reverting the binary is safe.
Rehearse the full sequence in a test environment
Build a test environment that matches production in Loki version, deployment mode, object store type and tenant setup. Run the full sequence there before any production change, using a copy or representative sample of production data. Record every error, warning and manual intervention, and turn each one into a written runbook step. Check: the rehearsal passes every check in this sequence, and the team can name the exact rollback actions for each stage. Rollback point: the test environment can be rebuilt from its own backup at any time, so failures here do not affect production.
Validate configuration against the 3.0 guide
Compare every configuration file against the 3.0 upgrade guide. Cover the index store and schema period entries, structured metadata, the shipper settings that 3.0 removes, and the default limits that now apply. Set limits explicitly where your logs depend on them so that new defaults do not start rejecting expected logs. Check: a validation run starts the 3.0 binary without configuration errors, and a named owner signs off the reviewed diff. Rollback point: all changes sit in version control, so reverting the commit restores the 2.x configuration without touching stored data.
Upgrade a non-production environment
Deploy the 3.0 binaries to a non-production environment that receives live or replayed ingestion traffic. Follow the guide's order for components and keep the 2.x binaries and configuration staged so either version can be restored. Let the environment run long enough for your team to observe ingestion and component health. Check: every component reports healthy, cluster membership is stable, and shippers such as Grafana Alloy deliver logs without unexplained drops. Rollback point: before any index or schema migration runs, reverting the binaries and configuration is safe.
Run the index and schema migration steps
Run the index and schema migration steps the official guide requires, including the transition to TSDB and schema v13, in the non-production environment first. Do not skip any step the guide marks as required. Record start and end times, object counts and all migration output. Check: queries against data written before and after the schema cut point return the expected results, and the configuration reports the intended schema period. Rollback point: reverting the binary alone may no longer be safe after this step. Restore from the backup taken in the first step, and rehearse that restore before production.
Check ingestion and queries against the baseline
Compare ingestion rate, rejected-line counts, write and read latency, and query results with the baseline recorded in the first step. Run the queries your teams rely on most, and confirm that Grafana data sources connect correctly, including the X-Scope-OrgID header where multi-tenancy is enabled. Check: rejected-line counts match the baseline or have documented causes, and key dashboards return the same results as before. Rollback point: until production cutover, the upgraded non-production environment can be restored from its backup without affecting users.
Roll out to production by component or mode
Upgrade production in the order the guide sets, one component group or deployment mode at a time, with a pause and the same checks after each group. If you run simple scalable mode, which is being deprecated and removed in Loki 4.0, confirm the read, write and backend targets with the guide before you start. Check: each group passes the ingestion and query checks before the next group begins. Rollback point: a group can be reverted to 2.x while the migration has not yet run against production data. After that point, recovery means restoring from the first-step backup.
Confirm retention and limits after cutover
Review the retention settings, which are disabled by default, and confirm they apply as intended globally, per tenant or per stream selector. Each stream rule must be at least 24 hours. Review tenant limits against observed volumes so that default limits do not reject expected logs. Check: a signed retention and limits report from the platform owner, and a test stream confirms that expiry behaves as the rules describe. Rollback point: enable retention only after this review, because deleted chunks cannot be recovered except from the first-step backup.
How to test a Loki upgrade and decide when to roll back
Agree the test scope and the rollback criteria before the upgrade window opens, not during it. The scope should cover five areas: ingestion from every shipper in use, query results compared before and after the change, retention behavior, tenant isolation, and Grafana dashboards and alert rules. Start with an inventory of shippers. Include every Grafana Alloy pipeline, any Fluent Bit, Fluentd or Docker logging driver source, and any OpenTelemetry client that posts logs over HTTP. Each source needs a known test line that you can search for after the upgrade, so that a missing stream is detected quickly and attributed to a specific source.
For ingestion, send a labeled marker from each shipper before and after the change and confirm that it is queryable with the same labels and a correct timestamp. For queries, choose a fixed set of representative LogQL queries, record result counts and sample lines on the 2.x cluster, and rerun the same queries on 3.0. Expect some differences where label handling or structured metadata changed, and document each one as either accepted or defective. Also watch the write path for rejected logs. Version 3.0 introduces new default limits that can reject logs, so check rejection metrics and error lines across a soak period, not only at the first request.
Retention needs a deliberate check. The compactor applies retention, and retention is disabled by default, so logs are kept indefinitely until retention_enabled is set. Confirm the value in the configuration you will actually run, then verify that expired data is removed only from the streams and tenants you intended, using a test tenant with short, known rules. If auth_enabled is true, send requests with each tenant's X-Scope-OrgID header and confirm that one tenant cannot read another tenant's streams and that requests without the header are refused. Loki has no built-in authentication, so also confirm that the authenticating reverse proxy in front of it still enforces identity on the upgraded deployment, and that Grafana data sources send the correct tenant header.
Set rollback criteria in general terms before the window opens. Typical triggers are unrecoverable loss of ingested logs, sustained rejection of logs caused by new limits that configuration changes cannot clear, and query failures on dashboards and alerts that operations depends on. Name a decision owner and a deadline for making the call. Rollback is clean only while the new schema has not been relied on. Once the cluster has written data that depends on TSDB and schema v13, or on structured metadata, reverting the binary generally does not undo that layout, so the simple reversal window closes at the first write that depends on it. Confirm with the official upgrade guide which rollback steps it supports for your storage backend and deployment mode before you rely on any of them.
What drives the effort of a Loki 2.x to 3.0 upgrade
This table lists the factors that most change how much work a Loki 2.x to 3.0 upgrade requires. Read each row as a question to answer about your current environment before estimating the work. The main takeaway is that tenant limits, label-dependent alerts and the state of your backups usually matter more than raw log volume.
| Driver | Why it increases effort | What to check |
|---|---|---|
| Deployment mode | Monolithic, simple scalable and microservices modes restart components differently. Simple scalable mode is deprecated for removal in 4.0. | Confirm your current mode and whether the target topology moves off simple scalable. |
| Daily volume and retained data | Higher ingest and larger stored data mean more to verify, longer rollback windows and more time for storage checks. | Measure daily ingest and total object storage size, then confirm the cutover plan fits those figures. |
| Tenants and per-tenant limits | Loki 3.0 has new default limits that can reject logs the old defaults accepted. Each custom override needs review. | List tenants, X-Scope-OrgID values and overrides, and compare each override with the 3.0 defaults. |
| Custom retention rules | Retention is disabled by default and can be set globally, per tenant or per stream selector. Rules must be carried over and retested. | Export current compactor and retention settings, then confirm each stream rule still matches the intended labels. |
| Index and schema changes | Moving to TSDB and schema v13 with structured metadata changes how data is indexed and queried, and removed shipper settings need replacing. | Check your current index store and schema config, and list any settings the 3.0 guide removes. |
| Log shippers | Promtail is end of life, and each shipper handles labels and metadata differently. Each sender may need its own configuration change. | Inventory Promtail, Alloy, Fluent Bit, Fluentd, Docker logging driver and OpenTelemetry senders, and note which need changes. |
| Authentication proxy | Loki has no built-in authentication, so the proxy must keep passing the tenant header and allow every endpoint the upgrade uses. | Test write and query paths through the proxy with the tenant header in staging before cutover. |
| Dashboards and alerts on labels | Changes to label handling can alter query results. Alerts that depend on specific labels can stop firing without an error. | Catalog dashboards and alert rules that use labels, then compare representative LogQL query results before and after. |
| Tested backup and staging environment | Without a tested restore and a staging copy with matching config and sample data, rollback depends on assumptions. | Confirm a restore of index and chunk storage has been tested, and that staging matches production config. |
Planning the 3.0 upgrade with the removal of simple scalable mode in 4.0
If your Loki 2.x deployment runs in simple scalable mode, the Loki documentation states that this mode is being deprecated and will be removed with the Loki 4.0 release. The practical consequence is that the topology you choose for 3.0 is not a decision you can defer indefinitely. Before you schedule the upgrade, decide whether you will stay on simple scalable mode through 3.0 and move later, or change topology as part of the 3.0 work. Record that decision with its reasons so the team can revisit it when the 4.0 guidance is available.
The first path upgrades to 3.0 on the current read, write and backend layout, then moves to monolithic or microservices in a separate change. Each change is smaller and easier to roll back, but you run two maintenance windows, two validation cycles and two sets of client-facing checks. The second path combines the topology change with the 3.0 upgrade. That gives you one window, but it adds variables at the same time: the move to TSDB and schema v13, structured metadata, removed shipper settings, new default limits and a new process layout. If something misbehaves, it becomes harder to tell which change caused it. Pick the path your team can test and roll back with confidence.
The choice depends mainly on three inputs. The first is daily log volume. The Loki deployment modes documentation describes monolithic mode as suited to a single binary handling up to about 20 GB of logs per day, simple scalable mode as approaching 1 TB per day, and microservices for very large clusters. Measure your current ingest over a representative period, including peaks, rather than relying on a monthly average. The second is team operating capacity: microservices means more components to deploy, scale, monitor and upgrade. The third is query load and retention, which affect how much read capacity you need. Ask whoever will run Loki to estimate their weekly operating time for each option.
Confirm the official Loki 4.0 guidance before you fix the target topology. The documentation establishes the deprecation and the removal release, but it does not, in the material this plan relies on, describe the replacement path, the supported modes in 4.0, or the configuration changes that will be required. Check the Loki release notes on GitHub and the Grafana documentation when the guidance is published, and update your decision record. Until then, treat any second migration timeline as unknown. If you ask a partner to scope this work, request written options for each path, with the effort each one assumes for your own environment.
Questions teams ask before a Loki 2.x to 3.0 upgrade
What drives the cost of a Loki 2.x to 3.0 upgrade, and which parts are one-time?
Cost follows the size and state of your existing deployment and how much of it changes. One-time work covers the assessment, the configuration changes the official upgrade guide requires, the move to the TSDB index and schema v13, decisions about structured metadata, review of the default limits that can reject logs, a test run against copies of your data, and the cutover itself. Recurring work is whatever continues after the upgrade: monitoring, compactor and retention checks, object storage costs, and any retainer for ongoing support. Each cost rises with the number of deployments and tenants, the number of dashboards and alert rules that query Loki, the number of log shippers that need changes, and whether Promtail is involved. Ask for a quote that splits these lines so you can see what is paid once and what continues.
How long does a Loki 2.x to 3.0 upgrade take?
No duration is given here, because the time depends on your environment, and any figure without a scoped plan would be guesswork. The main drivers are the number of Loki deployments and environments, the size of the stored chunks and index in object storage, how many tenants, retention rules and limits you run, how many log shippers and dashboards need review, and how quickly your team approves each test result. Fixed-scope work gets a timeline in the written scope before work starts, based on a review of your current setup. Ask the provider to show which tasks sit on the critical path, such as data checks and the change window, and which depend on your team's availability. Also ask how long the test period runs before production.
What does the upgrade need from our team?
Plan for named people and access before work starts. You need read access to the current Loki configuration, the storage buckets or filesystem that hold chunks and the index, and the deployment manifests or Helm values that run Loki. Your team should also give access to the Grafana dashboards and alert rules that query Loki, so compatibility can be checked. A test environment that resembles production in topology and approximate data volume is needed for rehearsal. Finally, assign an owner who can approve changes to limits, retention and tenant settings, and who signs off each test result and the cutover. Without that owner, decisions stall and testing slips.
Can our own team upgrade Loki 2.x to 3.0 without a partner?
Yes, a team can, if it works from the official upgrade guide and has time to test. The guide covers the changes that matter most: moving to TSDB and schema v13, adopting structured metadata, removing shipper settings that no longer apply, and setting limits deliberately so valid logs are not rejected. The skills required include Linux and your Kubernetes or deployment tooling, object storage administration, Loki configuration and limits, and Grafana and LogQL for verification. Your team also needs enough log pipeline knowledge to test ingestion from source to query. Most risk comes from testing that gets skipped under deadline pressure. If your team lacks one of these skills or lacks time, a fixed-scope engagement can fill that gap.
Will we lose logs if the Loki upgrade goes wrong?
A well-planned upgrade makes log loss unlikely, but no provider can guarantee it. Protection comes from three things: a verified backup of the object storage data and index before cutover, a rollback point you have actually tested, and a period in which the old setup can be restored or your shippers can be pointed back. Ask which backup method the provider uses, how long a rollback takes, and what happens to logs written while the new version runs. Also check retention. Retention is applied by the compactor and is disabled by default, so logs are kept until retention is enabled, and a retention change made during the upgrade can delete data. Ask for backup, rollback and retention steps to be written into the scope and test plan.
Does the upgrade include moving Promtail agents to Grafana Alloy?
It depends on scope, so decide it before you request a quote. Promtail reached end of life on March 2, 2026, with no further updates or commercial support, and Grafana directs users to migrate to Grafana Alloy. The Loki upgrade does not replace your shippers, so every agent that sends logs needs to be checked against the upgraded server. Confirm who owns the Alloy rollout, whether it is in scope, how many hosts or clusters it affects, and who verifies that logs arrive with the expected labels after the switch. Shipper changes often touch more teams than the Loki platform team, so name a contact for each log source.
What should we ask for in a written Loki upgrade quote?
Ask for a quote built on a written scope. DeployOpen does not publish a price list, and most engagements are fixed-scope, with scope, deliverables and timelines agreed in writing before work starts. The quote should list the environments covered, such as development, staging and production, and each Loki deployment and tenant included. Check the deliverables: configuration changes, test reports, a runbook, a rollback plan and handover notes. Confirm testing responsibilities, including who runs test cases, who signs off, and what happens when a test fails. Name who is responsible for rollback, and state who handles the Promtail to Alloy changes and whether that work is priced separately. Finally, ask whether ongoing support, upgrades or continuous testing should run as a retainer, and what that retainer covers.
Should we buy ongoing support after the Loki 3.0 upgrade?
Ongoing support is optional, and many teams decide after cutover, once they see how the platform behaves in production. A retainer can cover recurring work such as monitoring reviews, applying patch releases, planning later upgrades, checking retention and limits as volumes grow, and responding to issues under the terms agreed in writing. Simple scalable deployment mode is being removed with Loki 4.0, so a retainer can also plan that later change. A practical sequence is to run the upgrade as fixed scope first, then decide whether the ongoing operating load justifies a retainer. Ask the provider to state what the retainer covers, how changes are scoped, and which tasks stay with your team.
How DeployOpen scopes, delivers and supports a Loki upgrade
DeployOpen plans, implements, documents and supports self-hosted open-source platforms inside your own infrastructure, including the Loki 2.x to 3.0 upgrade. We start from the schema, storage and configuration changes in the official upgrade guide, then agree the work in writing before anything changes in your environment.
How we scope
- A written scope lists which Loki 2.x clusters, tenants and log sources the upgrade covers.
- Engagements are fixed-scope, so deliverables and timelines are agreed in writing before work starts.
- The scope should inventory existing limits, since new default limits can reject logs after upgrade.
How we build
- Rebuild a non-production copy of your Loki 2.x deployment and run the upgrade there first.
- Convert storage to TSDB and schema v13 following the upgrade guide, step by step, with recorded commands.
- Test queries, retention, X-Scope-OrgID tenant routing and Grafana access against the upgraded copy.
How we hand over
- A written runbook covering the new configuration, schema settings, rollback steps and known limits.
- Deployment mode review noting that simple scalable mode is being removed in Loki 4.0.
- Knowledge transfer session with your platform engineers on upgrade steps and post-upgrade checks.
How we support
- An optional retainer covers ongoing support and upgrades after handover, agreed in writing.
- Post-upgrade checks watch for ingestion rejections from default limits and confirm retention still runs.
- Ongoing Loki version reviews confirm the release you run and the deprecation status of its components.

