Configure GCP Service Quota Overrides

The gcp:serviceusage/consumerQuotaOverride:ConsumerQuotaOverride resource, part of the Pulumi GCP provider, applies consumer-initiated quota limits to reduce a project’s own quota usage below service defaults. This guide focuses on three capabilities: project-wide limits, regional scoping, and custom dimension targeting.

Consumer overrides reference existing projects and enabled services. They cannot grant more quota than admin overrides or service defaults allow; they only reduce quotas. The examples are intentionally small. Combine them with your own project structure and quota monitoring.

Set a project-wide quota limit

Teams managing API usage often cap their own consumption to prevent unexpected costs or ensure fair resource distribution across environments.

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
import * as std from "@pulumi/std";

const myProject = new gcp.organizations.Project("my_project", {
    name: "tf-test-project",
    projectId: "quota",
    orgId: "123456789",
    deletionPolicy: "DELETE",
});
const override = new gcp.serviceusage.ConsumerQuotaOverride("override", {
    project: myProject.projectId,
    service: "servicemanagement.googleapis.com",
    metric: std.urlencode({
        input: "servicemanagement.googleapis.com/default_requests",
    }).then(invoke => invoke.result),
    limit: std.urlencode({
        input: "/min/project",
    }).then(invoke => invoke.result),
    overrideValue: "95",
    force: true,
});

import pulumi
import pulumi_gcp as gcp
import pulumi_std as std

my_project = gcp.organizations.Project("my_project",
    name="tf-test-project",
    project_id="quota",
    org_id="123456789",
    deletion_policy="DELETE")
override = gcp.serviceusage.ConsumerQuotaOverride("override",
    project=my_project.project_id,
    service="servicemanagement.googleapis.com",
    metric=std.urlencode(input="servicemanagement.googleapis.com/default_requests").result,
    limit=std.urlencode(input="/min/project").result,
    override_value="95",
    force=True)

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/organizations"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/serviceusage"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		myProject, err := organizations.NewProject(ctx, "my_project", &organizations.ProjectArgs{
			Name:           pulumi.String("tf-test-project"),
			ProjectId:      pulumi.String("quota"),
			OrgId:          pulumi.String("123456789"),
			DeletionPolicy: pulumi.String("DELETE"),
		})
		if err != nil {
			return err
		}
		invokeUrlencode, err := std.Urlencode(ctx, &std.UrlencodeArgs{
			Input: "servicemanagement.googleapis.com/default_requests",
		}, nil)
		if err != nil {
			return err
		}
		invokeUrlencode1, err := std.Urlencode(ctx, &std.UrlencodeArgs{
			Input: "/min/project",
		}, nil)
		if err != nil {
			return err
		}
		_, err = serviceusage.NewConsumerQuotaOverride(ctx, "override", &serviceusage.ConsumerQuotaOverrideArgs{
			Project:       myProject.ProjectId,
			Service:       pulumi.String("servicemanagement.googleapis.com"),
			Metric:        pulumi.String(invokeUrlencode.Result),
			Limit:         pulumi.String(invokeUrlencode1.Result),
			OverrideValue: pulumi.String("95"),
			Force:         pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() => 
{
    var myProject = new Gcp.Organizations.Project("my_project", new()
    {
        Name = "tf-test-project",
        ProjectId = "quota",
        OrgId = "123456789",
        DeletionPolicy = "DELETE",
    });

    var @override = new Gcp.ServiceUsage.ConsumerQuotaOverride("override", new()
    {
        Project = myProject.ProjectId,
        Service = "servicemanagement.googleapis.com",
        Metric = Std.Urlencode.Invoke(new()
        {
            Input = "servicemanagement.googleapis.com/default_requests",
        }).Apply(invoke => invoke.Result),
        Limit = Std.Urlencode.Invoke(new()
        {
            Input = "/min/project",
        }).Apply(invoke => invoke.Result),
        OverrideValue = "95",
        Force = true,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.organizations.Project;
import com.pulumi.gcp.organizations.ProjectArgs;
import com.pulumi.gcp.serviceusage.ConsumerQuotaOverride;
import com.pulumi.gcp.serviceusage.ConsumerQuotaOverrideArgs;
import com.pulumi.std.StdFunctions;
import com.pulumi.std.inputs.UrlencodeArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var myProject = new Project("myProject", ProjectArgs.builder()
            .name("tf-test-project")
            .projectId("quota")
            .orgId("123456789")
            .deletionPolicy("DELETE")
            .build());

        var override = new ConsumerQuotaOverride("override", ConsumerQuotaOverrideArgs.builder()
            .project(myProject.projectId())
            .service("servicemanagement.googleapis.com")
            .metric(StdFunctions.urlencode(UrlencodeArgs.builder()
                .input("servicemanagement.googleapis.com/default_requests")
                .build()).result())
            .limit(StdFunctions.urlencode(UrlencodeArgs.builder()
                .input("/min/project")
                .build()).result())
            .overrideValue("95")
            .force(true)
            .build());

    }
}

resources:
  myProject:
    type: gcp:organizations:Project
    name: my_project
    properties:
      name: tf-test-project
      projectId: quota
      orgId: '123456789'
      deletionPolicy: DELETE
  override:
    type: gcp:serviceusage:ConsumerQuotaOverride
    properties:
      project: ${myProject.projectId}
      service: servicemanagement.googleapis.com
      metric:
        fn::invoke:
          function: std:urlencode
          arguments:
            input: servicemanagement.googleapis.com/default_requests
          return: result
      limit:
        fn::invoke:
          function: std:urlencode
          arguments:
            input: /min/project
          return: result
      overrideValue: '95'
      force: true

The service property identifies which API the quota applies to. The metric property specifies what’s being limited (e.g., request rate), and limit defines the scope (e.g., /min/project for per-minute project-wide limits). The overrideValue sets the new cap; force bypasses the safety check that rejects reductions greater than 10%.

Limit quota for a specific region

Some quotas are scoped to regions rather than projects. When you need to control resource usage in a particular geographic area, you can apply overrides with regional dimensions.

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
import * as std from "@pulumi/std";

const myProject = new gcp.organizations.Project("my_project", {
    name: "tf-test-project",
    projectId: "quota",
    orgId: "123456789",
    deletionPolicy: "DELETE",
});
const override = new gcp.serviceusage.ConsumerQuotaOverride("override", {
    dimensions: {
        region: "us-central1",
    },
    project: myProject.projectId,
    service: "compute.googleapis.com",
    metric: std.urlencode({
        input: "compute.googleapis.com/n2_cpus",
    }).then(invoke => invoke.result),
    limit: std.urlencode({
        input: "/project/region",
    }).then(invoke => invoke.result),
    overrideValue: "8",
    force: true,
});

import pulumi
import pulumi_gcp as gcp
import pulumi_std as std

my_project = gcp.organizations.Project("my_project",
    name="tf-test-project",
    project_id="quota",
    org_id="123456789",
    deletion_policy="DELETE")
override = gcp.serviceusage.ConsumerQuotaOverride("override",
    dimensions={
        "region": "us-central1",
    },
    project=my_project.project_id,
    service="compute.googleapis.com",
    metric=std.urlencode(input="compute.googleapis.com/n2_cpus").result,
    limit=std.urlencode(input="/project/region").result,
    override_value="8",
    force=True)

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/organizations"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/serviceusage"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		myProject, err := organizations.NewProject(ctx, "my_project", &organizations.ProjectArgs{
			Name:           pulumi.String("tf-test-project"),
			ProjectId:      pulumi.String("quota"),
			OrgId:          pulumi.String("123456789"),
			DeletionPolicy: pulumi.String("DELETE"),
		})
		if err != nil {
			return err
		}
		invokeUrlencode, err := std.Urlencode(ctx, &std.UrlencodeArgs{
			Input: "compute.googleapis.com/n2_cpus",
		}, nil)
		if err != nil {
			return err
		}
		invokeUrlencode1, err := std.Urlencode(ctx, &std.UrlencodeArgs{
			Input: "/project/region",
		}, nil)
		if err != nil {
			return err
		}
		_, err = serviceusage.NewConsumerQuotaOverride(ctx, "override", &serviceusage.ConsumerQuotaOverrideArgs{
			Dimensions: pulumi.StringMap{
				"region": pulumi.String("us-central1"),
			},
			Project:       myProject.ProjectId,
			Service:       pulumi.String("compute.googleapis.com"),
			Metric:        pulumi.String(invokeUrlencode.Result),
			Limit:         pulumi.String(invokeUrlencode1.Result),
			OverrideValue: pulumi.String("8"),
			Force:         pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() => 
{
    var myProject = new Gcp.Organizations.Project("my_project", new()
    {
        Name = "tf-test-project",
        ProjectId = "quota",
        OrgId = "123456789",
        DeletionPolicy = "DELETE",
    });

    var @override = new Gcp.ServiceUsage.ConsumerQuotaOverride("override", new()
    {
        Dimensions = 
        {
            { "region", "us-central1" },
        },
        Project = myProject.ProjectId,
        Service = "compute.googleapis.com",
        Metric = Std.Urlencode.Invoke(new()
        {
            Input = "compute.googleapis.com/n2_cpus",
        }).Apply(invoke => invoke.Result),
        Limit = Std.Urlencode.Invoke(new()
        {
            Input = "/project/region",
        }).Apply(invoke => invoke.Result),
        OverrideValue = "8",
        Force = true,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.organizations.Project;
import com.pulumi.gcp.organizations.ProjectArgs;
import com.pulumi.gcp.serviceusage.ConsumerQuotaOverride;
import com.pulumi.gcp.serviceusage.ConsumerQuotaOverrideArgs;
import com.pulumi.std.StdFunctions;
import com.pulumi.std.inputs.UrlencodeArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var myProject = new Project("myProject", ProjectArgs.builder()
            .name("tf-test-project")
            .projectId("quota")
            .orgId("123456789")
            .deletionPolicy("DELETE")
            .build());

        var override = new ConsumerQuotaOverride("override", ConsumerQuotaOverrideArgs.builder()
            .dimensions(Map.of("region", "us-central1"))
            .project(myProject.projectId())
            .service("compute.googleapis.com")
            .metric(StdFunctions.urlencode(UrlencodeArgs.builder()
                .input("compute.googleapis.com/n2_cpus")
                .build()).result())
            .limit(StdFunctions.urlencode(UrlencodeArgs.builder()
                .input("/project/region")
                .build()).result())
            .overrideValue("8")
            .force(true)
            .build());

    }
}

resources:
  myProject:
    type: gcp:organizations:Project
    name: my_project
    properties:
      name: tf-test-project
      projectId: quota
      orgId: '123456789'
      deletionPolicy: DELETE
  override:
    type: gcp:serviceusage:ConsumerQuotaOverride
    properties:
      dimensions:
        region: us-central1
      project: ${myProject.projectId}
      service: compute.googleapis.com
      metric:
        fn::invoke:
          function: std:urlencode
          arguments:
            input: compute.googleapis.com/n2_cpus
          return: result
      limit:
        fn::invoke:
          function: std:urlencode
          arguments:
            input: /project/region
          return: result
      overrideValue: '8'
      force: true

The dimensions property targets the override to a specific region. Here, the override caps N2 CPU quota in us-central1 to 8 cores. The limit format /project/region indicates this quota is scoped per-project per-region.

Apply quota limits with custom dimensions

Some services define custom dimensions beyond region or zone. When a quota supports custom dimensions, you can target overrides to specific dimension values.

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
import * as std from "@pulumi/std";

const myProject = new gcp.organizations.Project("my_project", {
    name: "tf-test-project",
    projectId: "quota",
    orgId: "123456789",
    deletionPolicy: "DELETE",
});
const override = new gcp.serviceusage.ConsumerQuotaOverride("override", {
    project: myProject.projectId,
    service: "libraryagent.googleapis.com",
    metric: std.urlencode({
        input: "libraryagent.googleapis.com/borrows",
    }).then(invoke => invoke.result),
    limit: std.urlencode({
        input: "/author/project",
    }).then(invoke => invoke.result),
    overrideValue: "1",
    force: true,
    dimensions: {
        author: "larry",
    },
});

import pulumi
import pulumi_gcp as gcp
import pulumi_std as std

my_project = gcp.organizations.Project("my_project",
    name="tf-test-project",
    project_id="quota",
    org_id="123456789",
    deletion_policy="DELETE")
override = gcp.serviceusage.ConsumerQuotaOverride("override",
    project=my_project.project_id,
    service="libraryagent.googleapis.com",
    metric=std.urlencode(input="libraryagent.googleapis.com/borrows").result,
    limit=std.urlencode(input="/author/project").result,
    override_value="1",
    force=True,
    dimensions={
        "author": "larry",
    })

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/organizations"
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/serviceusage"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		myProject, err := organizations.NewProject(ctx, "my_project", &organizations.ProjectArgs{
			Name:           pulumi.String("tf-test-project"),
			ProjectId:      pulumi.String("quota"),
			OrgId:          pulumi.String("123456789"),
			DeletionPolicy: pulumi.String("DELETE"),
		})
		if err != nil {
			return err
		}
		invokeUrlencode, err := std.Urlencode(ctx, &std.UrlencodeArgs{
			Input: "libraryagent.googleapis.com/borrows",
		}, nil)
		if err != nil {
			return err
		}
		invokeUrlencode1, err := std.Urlencode(ctx, &std.UrlencodeArgs{
			Input: "/author/project",
		}, nil)
		if err != nil {
			return err
		}
		_, err = serviceusage.NewConsumerQuotaOverride(ctx, "override", &serviceusage.ConsumerQuotaOverrideArgs{
			Project:       myProject.ProjectId,
			Service:       pulumi.String("libraryagent.googleapis.com"),
			Metric:        pulumi.String(invokeUrlencode.Result),
			Limit:         pulumi.String(invokeUrlencode1.Result),
			OverrideValue: pulumi.String("1"),
			Force:         pulumi.Bool(true),
			Dimensions: pulumi.StringMap{
				"author": pulumi.String("larry"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() => 
{
    var myProject = new Gcp.Organizations.Project("my_project", new()
    {
        Name = "tf-test-project",
        ProjectId = "quota",
        OrgId = "123456789",
        DeletionPolicy = "DELETE",
    });

    var @override = new Gcp.ServiceUsage.ConsumerQuotaOverride("override", new()
    {
        Project = myProject.ProjectId,
        Service = "libraryagent.googleapis.com",
        Metric = Std.Urlencode.Invoke(new()
        {
            Input = "libraryagent.googleapis.com/borrows",
        }).Apply(invoke => invoke.Result),
        Limit = Std.Urlencode.Invoke(new()
        {
            Input = "/author/project",
        }).Apply(invoke => invoke.Result),
        OverrideValue = "1",
        Force = true,
        Dimensions = 
        {
            { "author", "larry" },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.organizations.Project;
import com.pulumi.gcp.organizations.ProjectArgs;
import com.pulumi.gcp.serviceusage.ConsumerQuotaOverride;
import com.pulumi.gcp.serviceusage.ConsumerQuotaOverrideArgs;
import com.pulumi.std.StdFunctions;
import com.pulumi.std.inputs.UrlencodeArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var myProject = new Project("myProject", ProjectArgs.builder()
            .name("tf-test-project")
            .projectId("quota")
            .orgId("123456789")
            .deletionPolicy("DELETE")
            .build());

        var override = new ConsumerQuotaOverride("override", ConsumerQuotaOverrideArgs.builder()
            .project(myProject.projectId())
            .service("libraryagent.googleapis.com")
            .metric(StdFunctions.urlencode(UrlencodeArgs.builder()
                .input("libraryagent.googleapis.com/borrows")
                .build()).result())
            .limit(StdFunctions.urlencode(UrlencodeArgs.builder()
                .input("/author/project")
                .build()).result())
            .overrideValue("1")
            .force(true)
            .dimensions(Map.of("author", "larry"))
            .build());

    }
}

resources:
  myProject:
    type: gcp:organizations:Project
    name: my_project
    properties:
      name: tf-test-project
      projectId: quota
      orgId: '123456789'
      deletionPolicy: DELETE
  override:
    type: gcp:serviceusage:ConsumerQuotaOverride
    properties:
      project: ${myProject.projectId}
      service: libraryagent.googleapis.com
      metric:
        fn::invoke:
          function: std:urlencode
          arguments:
            input: libraryagent.googleapis.com/borrows
          return: result
      limit:
        fn::invoke:
          function: std:urlencode
          arguments:
            input: /author/project
          return: result
      overrideValue: '1'
      force: true
      dimensions:
        author: larry

This example uses a custom dimension (author) specific to the library agent service. The dimensions property targets the override to a particular author value. The service documentation defines which dimensions are available for each metric.

Beyond these examples

These snippets focus on specific consumer quota override features: project-wide and regional quota limits, and custom dimension targeting. They’re intentionally minimal rather than full quota management solutions.

The examples reference pre-existing infrastructure such as GCP projects with enabled services, and understanding of service-specific quota metrics and limits. They focus on configuring the override rather than provisioning projects or enabling services.

To keep things focused, common quota management patterns are omitted, including:

Quota increase requests (consumer overrides only reduce quotas)
Admin or producer overrides (require organization-level permissions)
Monitoring quota usage before setting overrides
Handling force flag for large quota reductions

These omissions are intentional: the goal is to illustrate how each override feature is wired, not provide drop-in quota management modules. See the ConsumerQuotaOverride resource reference for all available configuration options.

Let's configure GCP Service Quota Overrides

Get started with Pulumi Cloud, then follow our quick setup guide to deploy this infrastructure.

Try Pulumi Cloud for FREE

Frequently Asked Questions

Configuration & Limits

What format should I use for the limit parameter?

The limit parameter must not start with 1/ or contain curly braces. Use formats like /project/user instead of 1/{project}/{user}.

Why do I need to URL-encode the metric and limit values?

All examples use std.urlencode for metric and limit parameters, indicating these values require URL encoding.

What does -1 mean for overrideValue?

Setting overrideValue to -1 grants unlimited quota. Otherwise, use any nonnegative integer.

Quota Management

Why is my quota decrease being rejected?

Decreasing quota by more than 10% is rejected by default as a safety check. Set force to true to bypass this protection.

Can I use consumer overrides to increase quota beyond the service default?

No, consumer overrides cannot grant more quota than allowed by admin overrides, producer overrides, or the default service limit. They can only reduce quota.

Regional & Custom Dimensions

How do I apply a quota override to a specific region?

Use the dimensions property with a region key, for example: dimensions: { region: "us-central1" }.

Can I use custom dimensions beyond region?

Yes, you can define custom dimensions in the dimensions map. The schema includes an example using a custom author dimension.

Resource Lifecycle

What properties are immutable after creation?

The limit, metric, project, service, and dimensions properties cannot be changed after creation. Only overrideValue and force are mutable.

Is this resource production-ready?

This resource is in beta and requires the terraform-provider-google-beta provider. Use with appropriate caution for production workloads.

What import formats are supported?

You can import using the full path (projects/.../services/.../consumerOverrides/...), service-relative path, or short format ({{service}}/{{metric}}/{{limit}}/{{name}}).

Using a different cloud?

Explore integration guides for other cloud providers:

AWS Guides Azure Guides