pulumi-gcp-kotlin/com.pulumi.gcp.cloudtasks.kotlin/Queue

Queue

class Queue : KotlinCustomResource

A named resource to which messages are sent by publishers.

Example Usage

Queue Basic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const _default = new gcp.cloudtasks.Queue("default", {
    name: "cloud-tasks-queue-test",
    location: "us-central1",
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
default = gcp.cloudtasks.Queue("default",
    name="cloud-tasks-queue-test",
    location="us-central1")
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var @default = new Gcp.CloudTasks.Queue("default", new()
    {
        Name = "cloud-tasks-queue-test",
        Location = "us-central1",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudtasks"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudtasks.NewQueue(ctx, "default", &cloudtasks.QueueArgs{
			Name:     pulumi.String("cloud-tasks-queue-test"),
			Location: pulumi.String("us-central1"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.cloudtasks.Queue;
import com.pulumi.gcp.cloudtasks.QueueArgs;
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 default_ = new Queue("default", QueueArgs.builder()
            .name("cloud-tasks-queue-test")
            .location("us-central1")
            .build());
    }
}
Content copied to clipboard
resources:
  default:
    type: gcp:cloudtasks:Queue
    properties:
      name: cloud-tasks-queue-test
      location: us-central1
Content copied to clipboard

Cloud Tasks Queue Advanced

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const advancedConfiguration = new gcp.cloudtasks.Queue("advanced_configuration", {
    name: "instance-name",
    location: "us-central1",
    appEngineRoutingOverride: {
        service: "worker",
        version: "1.0",
        instance: "test",
    },
    rateLimits: {
        maxConcurrentDispatches: 3,
        maxDispatchesPerSecond: 2,
    },
    retryConfig: {
        maxAttempts: 5,
        maxRetryDuration: "4s",
        maxBackoff: "3s",
        minBackoff: "2s",
        maxDoublings: 1,
    },
    stackdriverLoggingConfig: {
        samplingRatio: 0.9,
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
advanced_configuration = gcp.cloudtasks.Queue("advanced_configuration",
    name="instance-name",
    location="us-central1",
    app_engine_routing_override={
        "service": "worker",
        "version": "1.0",
        "instance": "test",
    },
    rate_limits={
        "max_concurrent_dispatches": 3,
        "max_dispatches_per_second": 2,
    },
    retry_config={
        "max_attempts": 5,
        "max_retry_duration": "4s",
        "max_backoff": "3s",
        "min_backoff": "2s",
        "max_doublings": 1,
    },
    stackdriver_logging_config={
        "sampling_ratio": 0.9,
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var advancedConfiguration = new Gcp.CloudTasks.Queue("advanced_configuration", new()
    {
        Name = "instance-name",
        Location = "us-central1",
        AppEngineRoutingOverride = new Gcp.CloudTasks.Inputs.QueueAppEngineRoutingOverrideArgs
        {
            Service = "worker",
            Version = "1.0",
            Instance = "test",
        },
        RateLimits = new Gcp.CloudTasks.Inputs.QueueRateLimitsArgs
        {
            MaxConcurrentDispatches = 3,
            MaxDispatchesPerSecond = 2,
        },
        RetryConfig = new Gcp.CloudTasks.Inputs.QueueRetryConfigArgs
        {
            MaxAttempts = 5,
            MaxRetryDuration = "4s",
            MaxBackoff = "3s",
            MinBackoff = "2s",
            MaxDoublings = 1,
        },
        StackdriverLoggingConfig = new Gcp.CloudTasks.Inputs.QueueStackdriverLoggingConfigArgs
        {
            SamplingRatio = 0.9,
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudtasks"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudtasks.NewQueue(ctx, "advanced_configuration", &cloudtasks.QueueArgs{
			Name:     pulumi.String("instance-name"),
			Location: pulumi.String("us-central1"),
			AppEngineRoutingOverride: &cloudtasks.QueueAppEngineRoutingOverrideArgs{
				Service:  pulumi.String("worker"),
				Version:  pulumi.String("1.0"),
				Instance: pulumi.String("test"),
			},
			RateLimits: &cloudtasks.QueueRateLimitsArgs{
				MaxConcurrentDispatches: pulumi.Int(3),
				MaxDispatchesPerSecond:  pulumi.Float64(2),
			},
			RetryConfig: &cloudtasks.QueueRetryConfigArgs{
				MaxAttempts:      pulumi.Int(5),
				MaxRetryDuration: pulumi.String("4s"),
				MaxBackoff:       pulumi.String("3s"),
				MinBackoff:       pulumi.String("2s"),
				MaxDoublings:     pulumi.Int(1),
			},
			StackdriverLoggingConfig: &cloudtasks.QueueStackdriverLoggingConfigArgs{
				SamplingRatio: pulumi.Float64(0.9),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.cloudtasks.Queue;
import com.pulumi.gcp.cloudtasks.QueueArgs;
import com.pulumi.gcp.cloudtasks.inputs.QueueAppEngineRoutingOverrideArgs;
import com.pulumi.gcp.cloudtasks.inputs.QueueRateLimitsArgs;
import com.pulumi.gcp.cloudtasks.inputs.QueueRetryConfigArgs;
import com.pulumi.gcp.cloudtasks.inputs.QueueStackdriverLoggingConfigArgs;
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 advancedConfiguration = new Queue("advancedConfiguration", QueueArgs.builder()
            .name("instance-name")
            .location("us-central1")
            .appEngineRoutingOverride(QueueAppEngineRoutingOverrideArgs.builder()
                .service("worker")
                .version("1.0")
                .instance("test")
                .build())
            .rateLimits(QueueRateLimitsArgs.builder()
                .maxConcurrentDispatches(3)
                .maxDispatchesPerSecond(2)
                .build())
            .retryConfig(QueueRetryConfigArgs.builder()
                .maxAttempts(5)
                .maxRetryDuration("4s")
                .maxBackoff("3s")
                .minBackoff("2s")
                .maxDoublings(1)
                .build())
            .stackdriverLoggingConfig(QueueStackdriverLoggingConfigArgs.builder()
                .samplingRatio(0.9)
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  advancedConfiguration:
    type: gcp:cloudtasks:Queue
    name: advanced_configuration
    properties:
      name: instance-name
      location: us-central1
      appEngineRoutingOverride:
        service: worker
        version: '1.0'
        instance: test
      rateLimits:
        maxConcurrentDispatches: 3
        maxDispatchesPerSecond: 2
      retryConfig:
        maxAttempts: 5
        maxRetryDuration: 4s
        maxBackoff: 3s
        minBackoff: 2s
        maxDoublings: 1
      stackdriverLoggingConfig:
        samplingRatio: 0.9
Content copied to clipboard

Import

Queue can be imported using any of these accepted formats:

  • projects/{{project}}/locations/{{location}}/queues/{{name}}

  • {{project}}/{{location}}/{{name}}

  • {{location}}/{{name}} When using the pulumi import command, Queue can be imported using one of the formats above. For example:

$ pulumi import gcp:cloudtasks/queue:Queue default projects/{{project}}/locations/{{location}}/queues/{{name}}
Content copied to clipboard
$ pulumi import gcp:cloudtasks/queue:Queue default {{project}}/{{location}}/{{name}}
Content copied to clipboard
$ pulumi import gcp:cloudtasks/queue:Queue default {{location}}/{{name}}
Content copied to clipboard

Properties

Link copied to clipboard
val appEngineRoutingOverride: Output<QueueAppEngineRoutingOverride>?

Overrides for task-level appEngineRouting. These settings apply only to App Engine tasks in this queue Structure is documented below.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val location: Output<String>

The location of the queue

Link copied to clipboard
val name: Output<String>

The queue name.

Link copied to clipboard
val project: Output<String>

The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val rateLimits: Output<QueueRateLimits>

Rate limits for task dispatches. The queue's actual dispatch rate is the result of:

Link copied to clipboard
val retryConfig: Output<QueueRetryConfig>

Settings that determine the retry behavior. Structure is documented below.

Link copied to clipboard
val stackdriverLoggingConfig: Output<QueueStackdriverLoggingConfig>?

Configuration options for writing logs to Stackdriver Logging. Structure is documented below.

Link copied to clipboard
val urn: Output<String>