prefect.TaskRunConcurrencyLimit

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

const testWorkspace = prefect.getWorkspace({
    handle: "my-workspace",
});
const testTaskRunConcurrencyLimit = new prefect.TaskRunConcurrencyLimit("testTaskRunConcurrencyLimit", {
    workspaceId: testWorkspace.then(testWorkspace => testWorkspace.id),
    concurrencyLimit: 1,
    tag: "test-tag",
});
// Example of a task that will be limited to 1 concurrent run:
//from prefect import flow, task
//
//# This task will be limited to 1 concurrent run
//@task(tags=["test-tag"])
//def my_task():
//    print("Hello, I'm a task")
//
//
//@flow
//def my_flow():
//    my_task()
//
//
//if __name__ == "__main__":
//    my_flow()

import pulumi
import pulumi_prefect as prefect

test_workspace = prefect.get_workspace(handle="my-workspace")
test_task_run_concurrency_limit = prefect.TaskRunConcurrencyLimit("testTaskRunConcurrencyLimit",
    workspace_id=test_workspace.id,
    concurrency_limit=1,
    tag="test-tag")
# Example of a task that will be limited to 1 concurrent run:
#from prefect import flow, task
#
## This task will be limited to 1 concurrent run
#@task(tags=["test-tag"])
#def my_task():
#    print("Hello, I'm a task")
#
#
#@flow
#def my_flow():
#    my_task()
#
#
#if __name__ == "__main__":
#    my_flow()

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 {
		testWorkspace, err := prefect.LookupWorkspace(ctx, &prefect.LookupWorkspaceArgs{
			Handle: pulumi.StringRef("my-workspace"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = prefect.NewTaskRunConcurrencyLimit(ctx, "testTaskRunConcurrencyLimit", &prefect.TaskRunConcurrencyLimitArgs{
			WorkspaceId:      pulumi.String(testWorkspace.Id),
			ConcurrencyLimit: pulumi.Float64(1),
			Tag:              pulumi.String("test-tag"),
		})
		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 testWorkspace = Prefect.GetWorkspace.Invoke(new()
    {
        Handle = "my-workspace",
    });

    var testTaskRunConcurrencyLimit = new Prefect.TaskRunConcurrencyLimit("testTaskRunConcurrencyLimit", new()
    {
        WorkspaceId = testWorkspace.Apply(getWorkspaceResult => getWorkspaceResult.Id),
        ConcurrencyLimit = 1,
        Tag = "test-tag",
    });

    // Example of a task that will be limited to 1 concurrent run:
    //from prefect import flow, task
    //
    //# This task will be limited to 1 concurrent run
    //@task(tags=["test-tag"])
    //def my_task():
    //    print("Hello, I'm a task")
    //
    //
    //@flow
    //def my_flow():
    //    my_task()
    //
    //
    //if __name__ == "__main__":
    //    my_flow()
});

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.GetWorkspaceArgs;
import com.pulumi.prefect.TaskRunConcurrencyLimit;
import com.pulumi.prefect.TaskRunConcurrencyLimitArgs;
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 testWorkspace = PrefectFunctions.getWorkspace(GetWorkspaceArgs.builder()
            .handle("my-workspace")
            .build());

        var testTaskRunConcurrencyLimit = new TaskRunConcurrencyLimit("testTaskRunConcurrencyLimit", TaskRunConcurrencyLimitArgs.builder()
            .workspaceId(testWorkspace.applyValue(getWorkspaceResult -> getWorkspaceResult.id()))
            .concurrencyLimit(1)
            .tag("test-tag")
            .build());

        // Example of a task that will be limited to 1 concurrent run:
        //from prefect import flow, task
        //
        //# This task will be limited to 1 concurrent run
        //@task(tags=["test-tag"])
        //def my_task():
        //    print("Hello, I'm a task")
        //
        //
        //@flow
        //def my_flow():
        //    my_task()
        //
        //
        //if __name__ == "__main__":
        //    my_flow()
    }
}

resources:
  testTaskRunConcurrencyLimit: # Example of a task that will be limited to 1 concurrent run:
  # /*
  # from prefect import flow, task

  # This task will be limited to 1 concurrent run
  # @task(tags=["test-tag"])
  # def my_task():
  #     print("Hello, I'm a task")


  # @flow
  # def my_flow():
  #     my_task()


  # if __name__ == "__main__":
  #     my_flow()
  # */
    type: prefect:TaskRunConcurrencyLimit
    properties:
      workspaceId: ${testWorkspace.id}
      concurrencyLimit: 1
      tag: test-tag
variables:
  testWorkspace:
    fn::invoke:
      function: prefect:getWorkspace
      arguments:
        handle: my-workspace

var taskRunConcurrencyLimitResource = new Prefect.TaskRunConcurrencyLimit("taskRunConcurrencyLimitResource", new()
{
    ConcurrencyLimit = 0,
    Tag = "string",
    AccountId = "string",
    WorkspaceId = "string",
});

example, err := prefect.NewTaskRunConcurrencyLimit(ctx, "taskRunConcurrencyLimitResource", &prefect.TaskRunConcurrencyLimitArgs{
ConcurrencyLimit: pulumi.Float64(0),
Tag: pulumi.String("string"),
AccountId: pulumi.String("string"),
WorkspaceId: pulumi.String("string"),
})

var taskRunConcurrencyLimitResource = new TaskRunConcurrencyLimit("taskRunConcurrencyLimitResource", TaskRunConcurrencyLimitArgs.builder()
    .concurrencyLimit(0)
    .tag("string")
    .accountId("string")
    .workspaceId("string")
    .build());

task_run_concurrency_limit_resource = prefect.TaskRunConcurrencyLimit("taskRunConcurrencyLimitResource",
    concurrency_limit=0,
    tag="string",
    account_id="string",
    workspace_id="string")

const taskRunConcurrencyLimitResource = new prefect.TaskRunConcurrencyLimit("taskRunConcurrencyLimitResource", {
    concurrencyLimit: 0,
    tag: "string",
    accountId: "string",
    workspaceId: "string",
});

type: prefect:TaskRunConcurrencyLimit
properties:
    accountId: string
    concurrencyLimit: 0
    tag: string
    workspaceId: string