Docs Home Pulumi IaC Pulumi ESC Pulumi Cloud Packages Tutorials
  1. Packages
  2. Prefect Provider
  3. API Docs
  4. getGlobalConcurrencyLimit
prefect 2.20.1 published on Friday, Mar 7, 2025 by prefecthq
prefecthq/terraform-provider-prefect

prefect.getGlobalConcurrencyLimit

Explore with Pulumi AI

prefect logo
prefect 2.20.1 published on Friday, Mar 7, 2025 by prefecthq
prefecthq/terraform-provider-prefect

    Get information about an existing Global Concurrency Limit
    Use this data source to read down the pre-defined Global Concurrency Limits, to manage concurrency limits.
    For more information, see apply global concurrency and rate limits.

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
import * as prefect from "@pulumi/prefect";

const limitById = prefect.getGlobalConcurrencyLimit({
    id: "00000000-0000-0000-0000-000000000000",
    workspaceId: "00000000-0000-0000-0000-000000000000",
});
const limitByName = prefect.getGlobalConcurrencyLimit({
    name: "my-limit",
    workspaceId: "00000000-0000-0000-0000-000000000000",
});

    import pulumi
import pulumi_prefect as prefect

limit_by_id = prefect.get_global_concurrency_limit(id="00000000-0000-0000-0000-000000000000",
    workspace_id="00000000-0000-0000-0000-000000000000")
limit_by_name = prefect.get_global_concurrency_limit(name="my-limit",
    workspace_id="00000000-0000-0000-0000-000000000000")

    package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/prefect/v2/prefect"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := prefect.LookupGlobalConcurrencyLimit(ctx, &prefect.LookupGlobalConcurrencyLimitArgs{
			Id:          pulumi.StringRef("00000000-0000-0000-0000-000000000000"),
			WorkspaceId: pulumi.StringRef("00000000-0000-0000-0000-000000000000"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = prefect.LookupGlobalConcurrencyLimit(ctx, &prefect.LookupGlobalConcurrencyLimitArgs{
			Name:        pulumi.StringRef("my-limit"),
			WorkspaceId: pulumi.StringRef("00000000-0000-0000-0000-000000000000"),
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

    using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Prefect = Pulumi.Prefect;

return await Deployment.RunAsync(() => 
{
    var limitById = Prefect.GetGlobalConcurrencyLimit.Invoke(new()
    {
        Id = "00000000-0000-0000-0000-000000000000",
        WorkspaceId = "00000000-0000-0000-0000-000000000000",
    });

    var limitByName = Prefect.GetGlobalConcurrencyLimit.Invoke(new()
    {
        Name = "my-limit",
        WorkspaceId = "00000000-0000-0000-0000-000000000000",
    });

});

    package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.prefect.PrefectFunctions;
import com.pulumi.prefect.inputs.GetGlobalConcurrencyLimitArgs;
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) {
        final var limitById = PrefectFunctions.getGlobalConcurrencyLimit(GetGlobalConcurrencyLimitArgs.builder()
            .id("00000000-0000-0000-0000-000000000000")
            .workspaceId("00000000-0000-0000-0000-000000000000")
            .build());

        final var limitByName = PrefectFunctions.getGlobalConcurrencyLimit(GetGlobalConcurrencyLimitArgs.builder()
            .name("my-limit")
            .workspaceId("00000000-0000-0000-0000-000000000000")
            .build());

    }
}

    variables:
  limitById:
    fn::invoke:
      function: prefect:getGlobalConcurrencyLimit
      arguments:
        id: 00000000-0000-0000-0000-000000000000
        workspaceId: 00000000-0000-0000-0000-000000000000
  limitByName:
    fn::invoke:
      function: prefect:getGlobalConcurrencyLimit
      arguments:
        name: my-limit
        workspaceId: 00000000-0000-0000-0000-000000000000

    Using getGlobalConcurrencyLimit

    Two invocation forms are available. The direct form accepts plain arguments and either blocks until the result value is available, or returns a Promise-wrapped result. The output form accepts Input-wrapped arguments and returns an Output-wrapped result.

    function getGlobalConcurrencyLimit(args: GetGlobalConcurrencyLimitArgs, opts?: InvokeOptions): Promise<GetGlobalConcurrencyLimitResult>
function getGlobalConcurrencyLimitOutput(args: GetGlobalConcurrencyLimitOutputArgs, opts?: InvokeOptions): Output<GetGlobalConcurrencyLimitResult>
    def get_global_concurrency_limit(account_id: Optional[str] = None,
                                 created: Optional[str] = None,
                                 id: Optional[str] = None,
                                 name: Optional[str] = None,
                                 updated: Optional[str] = None,
                                 workspace_id: Optional[str] = None,
                                 opts: Optional[InvokeOptions] = None) -> GetGlobalConcurrencyLimitResult
def get_global_concurrency_limit_output(account_id: Optional[pulumi.Input[str]] = None,
                                 created: Optional[pulumi.Input[str]] = None,
                                 id: Optional[pulumi.Input[str]] = None,
                                 name: Optional[pulumi.Input[str]] = None,
                                 updated: Optional[pulumi.Input[str]] = None,
                                 workspace_id: Optional[pulumi.Input[str]] = None,
                                 opts: Optional[InvokeOptions] = None) -> Output[GetGlobalConcurrencyLimitResult]
    func LookupGlobalConcurrencyLimit(ctx *Context, args *LookupGlobalConcurrencyLimitArgs, opts ...InvokeOption) (*LookupGlobalConcurrencyLimitResult, error)
func LookupGlobalConcurrencyLimitOutput(ctx *Context, args *LookupGlobalConcurrencyLimitOutputArgs, opts ...InvokeOption) LookupGlobalConcurrencyLimitResultOutput

    > Note: This function is named LookupGlobalConcurrencyLimit in the Go SDK.

    public static class GetGlobalConcurrencyLimit 
{
    public static Task<GetGlobalConcurrencyLimitResult> InvokeAsync(GetGlobalConcurrencyLimitArgs args, InvokeOptions? opts = null)
    public static Output<GetGlobalConcurrencyLimitResult> Invoke(GetGlobalConcurrencyLimitInvokeArgs args, InvokeOptions? opts = null)
}
    public static CompletableFuture<GetGlobalConcurrencyLimitResult> getGlobalConcurrencyLimit(GetGlobalConcurrencyLimitArgs args, InvokeOptions options)
public static Output<GetGlobalConcurrencyLimitResult> getGlobalConcurrencyLimit(GetGlobalConcurrencyLimitArgs args, InvokeOptions options)

    fn::invoke:
  function: prefect:index/getGlobalConcurrencyLimit:getGlobalConcurrencyLimit
  arguments:
    # arguments dictionary

    The following arguments are supported:

    AccountId string
    Account ID (UUID), defaults to the account set in the provider
    Created string
    Timestamp of when the resource was created (RFC3339)
    Id string
    Global Concurrency Limit ID (UUID)
    Name string
    Name of the global concurrency limit
    Updated string
    Timestamp of when the resource was updated (RFC3339)
    WorkspaceId string
    Workspace ID (UUID), defaults to the workspace set in the provider
    AccountId string
    Account ID (UUID), defaults to the account set in the provider
    Created string
    Timestamp of when the resource was created (RFC3339)
    Id string
    Global Concurrency Limit ID (UUID)
    Name string
    Name of the global concurrency limit
    Updated string
    Timestamp of when the resource was updated (RFC3339)
    WorkspaceId string
    Workspace ID (UUID), defaults to the workspace set in the provider
    accountId String
    Account ID (UUID), defaults to the account set in the provider
    created String
    Timestamp of when the resource was created (RFC3339)
    id String
    Global Concurrency Limit ID (UUID)
    name String
    Name of the global concurrency limit
    updated String
    Timestamp of when the resource was updated (RFC3339)
    workspaceId String
    Workspace ID (UUID), defaults to the workspace set in the provider
    accountId string
    Account ID (UUID), defaults to the account set in the provider
    created string
    Timestamp of when the resource was created (RFC3339)
    id string
    Global Concurrency Limit ID (UUID)
    name string
    Name of the global concurrency limit
    updated string
    Timestamp of when the resource was updated (RFC3339)
    workspaceId string
    Workspace ID (UUID), defaults to the workspace set in the provider
    account_id str
    Account ID (UUID), defaults to the account set in the provider
    created str
    Timestamp of when the resource was created (RFC3339)
    id str
    Global Concurrency Limit ID (UUID)
    name str
    Name of the global concurrency limit
    updated str
    Timestamp of when the resource was updated (RFC3339)
    workspace_id str
    Workspace ID (UUID), defaults to the workspace set in the provider
    accountId String
    Account ID (UUID), defaults to the account set in the provider
    created String
    Timestamp of when the resource was created (RFC3339)
    id String
    Global Concurrency Limit ID (UUID)
    name String
    Name of the global concurrency limit
    updated String
    Timestamp of when the resource was updated (RFC3339)
    workspaceId String
    Workspace ID (UUID), defaults to the workspace set in the provider

    getGlobalConcurrencyLimit Result

    The following output properties are available:

    AccountId string
    Account ID (UUID), defaults to the account set in the provider
    Active bool
    Whether the global concurrency limit is active.
    ActiveSlots double
    The number of active slots.
    Created string
    Timestamp of when the resource was created (RFC3339)
    Id string
    Global Concurrency Limit ID (UUID)
    Limit double
    Maximum number of tasks that can run simultaneously
    Name string
    Name of the global concurrency limit
    SlotDecayPerSecond double
    The number of slots to decay per second.
    Updated string
    Timestamp of when the resource was updated (RFC3339)
    WorkspaceId string
    Workspace ID (UUID), defaults to the workspace set in the provider
    AccountId string
    Account ID (UUID), defaults to the account set in the provider
    Active bool
    Whether the global concurrency limit is active.
    ActiveSlots float64
    The number of active slots.
    Created string
    Timestamp of when the resource was created (RFC3339)
    Id string
    Global Concurrency Limit ID (UUID)
    Limit float64
    Maximum number of tasks that can run simultaneously
    Name string
    Name of the global concurrency limit
    SlotDecayPerSecond float64
    The number of slots to decay per second.
    Updated string
    Timestamp of when the resource was updated (RFC3339)
    WorkspaceId string
    Workspace ID (UUID), defaults to the workspace set in the provider
    accountId String
    Account ID (UUID), defaults to the account set in the provider
    active Boolean
    Whether the global concurrency limit is active.
    activeSlots Double
    The number of active slots.
    created String
    Timestamp of when the resource was created (RFC3339)
    id String
    Global Concurrency Limit ID (UUID)
    limit Double
    Maximum number of tasks that can run simultaneously
    name String
    Name of the global concurrency limit
    slotDecayPerSecond Double
    The number of slots to decay per second.
    updated String
    Timestamp of when the resource was updated (RFC3339)
    workspaceId String
    Workspace ID (UUID), defaults to the workspace set in the provider
    accountId string
    Account ID (UUID), defaults to the account set in the provider
    active boolean
    Whether the global concurrency limit is active.
    activeSlots number
    The number of active slots.
    created string
    Timestamp of when the resource was created (RFC3339)
    id string
    Global Concurrency Limit ID (UUID)
    limit number
    Maximum number of tasks that can run simultaneously
    name string
    Name of the global concurrency limit
    slotDecayPerSecond number
    The number of slots to decay per second.
    updated string
    Timestamp of when the resource was updated (RFC3339)
    workspaceId string
    Workspace ID (UUID), defaults to the workspace set in the provider
    account_id str
    Account ID (UUID), defaults to the account set in the provider
    active bool
    Whether the global concurrency limit is active.
    active_slots float
    The number of active slots.
    created str
    Timestamp of when the resource was created (RFC3339)
    id str
    Global Concurrency Limit ID (UUID)
    limit float
    Maximum number of tasks that can run simultaneously
    name str
    Name of the global concurrency limit
    slot_decay_per_second float
    The number of slots to decay per second.
    updated str
    Timestamp of when the resource was updated (RFC3339)
    workspace_id str
    Workspace ID (UUID), defaults to the workspace set in the provider
    accountId String
    Account ID (UUID), defaults to the account set in the provider
    active Boolean
    Whether the global concurrency limit is active.
    activeSlots Number
    The number of active slots.
    created String
    Timestamp of when the resource was created (RFC3339)
    id String
    Global Concurrency Limit ID (UUID)
    limit Number
    Maximum number of tasks that can run simultaneously
    name String
    Name of the global concurrency limit
    slotDecayPerSecond Number
    The number of slots to decay per second.
    updated String
    Timestamp of when the resource was updated (RFC3339)
    workspaceId String
    Workspace ID (UUID), defaults to the workspace set in the provider

    Package Details

    Repository
    prefect prefecthq/terraform-provider-prefect
    License
    Notes
    This Pulumi package is based on the prefect Terraform Provider.
    prefect logo
    prefect 2.20.1 published on Friday, Mar 7, 2025 by prefecthq
    prefecthq/terraform-provider-prefect