pulumi-gcp-kotlin/com.pulumi.gcp.eventarc.kotlin/TriggerArgs

TriggerArgs

data class TriggerArgs(val channel: Output<String>? = null, val destination: Output<TriggerDestinationArgs>? = null, val eventDataContentType: Output<String>? = null, val labels: Output<Map<String, String>>? = null, val location: Output<String>? = null, val matchingCriterias: Output<List<TriggerMatchingCriteriaArgs>>? = null, val name: Output<String>? = null, val project: Output<String>? = null, val serviceAccount: Output<String>? = null, val transport: Output<TriggerTransportArgs>? = null) : ConvertibleToJava<TriggerArgs>

The Eventarc Trigger resource

Example Usage

Basic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const _default = new gcp.cloudrun.Service("default", {
    name: "eventarc-service",
    location: "europe-west1",
    metadata: {
        namespace: "my-project-name",
    },
    template: {
        spec: {
            containers: [{
                image: "gcr.io/cloudrun/hello",
                ports: [{
                    containerPort: 8080,
                }],
            }],
            containerConcurrency: 50,
            timeoutSeconds: 100,
        },
    },
    traffics: [{
        percent: 100,
        latestRevision: true,
    }],
});
const primary = new gcp.eventarc.Trigger("primary", {
    name: "name",
    location: "europe-west1",
    matchingCriterias: [{
        attribute: "type",
        value: "google.cloud.pubsub.topic.v1.messagePublished",
    }],
    destination: {
        cloudRunService: {
            service: _default.name,
            region: "europe-west1",
        },
    },
    labels: {
        foo: "bar",
    },
});
const foo = new gcp.pubsub.Topic("foo", {name: "topic"});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
default = gcp.cloudrun.Service("default",
    name="eventarc-service",
    location="europe-west1",
    metadata={
        "namespace": "my-project-name",
    },
    template={
        "spec": {
            "containers": [{
                "image": "gcr.io/cloudrun/hello",
                "ports": [{
                    "container_port": 8080,
                }],
            }],
            "container_concurrency": 50,
            "timeout_seconds": 100,
        },
    },
    traffics=[{
        "percent": 100,
        "latest_revision": True,
    }])
primary = gcp.eventarc.Trigger("primary",
    name="name",
    location="europe-west1",
    matching_criterias=[{
        "attribute": "type",
        "value": "google.cloud.pubsub.topic.v1.messagePublished",
    }],
    destination={
        "cloud_run_service": {
            "service": default.name,
            "region": "europe-west1",
        },
    },
    labels={
        "foo": "bar",
    })
foo = gcp.pubsub.Topic("foo", name="topic")
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.CloudRun.Service("default", new()
    {
        Name = "eventarc-service",
        Location = "europe-west1",
        Metadata = new Gcp.CloudRun.Inputs.ServiceMetadataArgs
        {
            Namespace = "my-project-name",
        },
        Template = new Gcp.CloudRun.Inputs.ServiceTemplateArgs
        {
            Spec = new Gcp.CloudRun.Inputs.ServiceTemplateSpecArgs
            {
                Containers = new[]
                {
                    new Gcp.CloudRun.Inputs.ServiceTemplateSpecContainerArgs
                    {
                        Image = "gcr.io/cloudrun/hello",
                        Ports = new[]
                        {
                            new Gcp.CloudRun.Inputs.ServiceTemplateSpecContainerPortArgs
                            {
                                ContainerPort = 8080,
                            },
                        },
                    },
                },
                ContainerConcurrency = 50,
                TimeoutSeconds = 100,
            },
        },
        Traffics = new[]
        {
            new Gcp.CloudRun.Inputs.ServiceTrafficArgs
            {
                Percent = 100,
                LatestRevision = true,
            },
        },
    });
    var primary = new Gcp.Eventarc.Trigger("primary", new()
    {
        Name = "name",
        Location = "europe-west1",
        MatchingCriterias = new[]
        {
            new Gcp.Eventarc.Inputs.TriggerMatchingCriteriaArgs
            {
                Attribute = "type",
                Value = "google.cloud.pubsub.topic.v1.messagePublished",
            },
        },
        Destination = new Gcp.Eventarc.Inputs.TriggerDestinationArgs
        {
            CloudRunService = new Gcp.Eventarc.Inputs.TriggerDestinationCloudRunServiceArgs
            {
                Service = @default.Name,
                Region = "europe-west1",
            },
        },
        Labels =
        {
            { "foo", "bar" },
        },
    });
    var foo = new Gcp.PubSub.Topic("foo", new()
    {
        Name = "topic",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/cloudrun"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/eventarc"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/pubsub"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := cloudrun.NewService(ctx, "default", &cloudrun.ServiceArgs{
			Name:     pulumi.String("eventarc-service"),
			Location: pulumi.String("europe-west1"),
			Metadata: &cloudrun.ServiceMetadataArgs{
				Namespace: pulumi.String("my-project-name"),
			},
			Template: &cloudrun.ServiceTemplateArgs{
				Spec: &cloudrun.ServiceTemplateSpecArgs{
					Containers: cloudrun.ServiceTemplateSpecContainerArray{
						&cloudrun.ServiceTemplateSpecContainerArgs{
							Image: pulumi.String("gcr.io/cloudrun/hello"),
							Ports: cloudrun.ServiceTemplateSpecContainerPortArray{
								&cloudrun.ServiceTemplateSpecContainerPortArgs{
									ContainerPort: pulumi.Int(8080),
								},
							},
						},
					},
					ContainerConcurrency: pulumi.Int(50),
					TimeoutSeconds:       pulumi.Int(100),
				},
			},
			Traffics: cloudrun.ServiceTrafficArray{
				&cloudrun.ServiceTrafficArgs{
					Percent:        pulumi.Int(100),
					LatestRevision: pulumi.Bool(true),
				},
			},
		})
		if err != nil {
			return err
		}
		_, err = eventarc.NewTrigger(ctx, "primary", &eventarc.TriggerArgs{
			Name:     pulumi.String("name"),
			Location: pulumi.String("europe-west1"),
			MatchingCriterias: eventarc.TriggerMatchingCriteriaArray{
				&eventarc.TriggerMatchingCriteriaArgs{
					Attribute: pulumi.String("type"),
					Value:     pulumi.String("google.cloud.pubsub.topic.v1.messagePublished"),
				},
			},
			Destination: &eventarc.TriggerDestinationArgs{
				CloudRunService: &eventarc.TriggerDestinationCloudRunServiceArgs{
					Service: _default.Name,
					Region:  pulumi.String("europe-west1"),
				},
			},
			Labels: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
		})
		if err != nil {
			return err
		}
		_, err = pubsub.NewTopic(ctx, "foo", &pubsub.TopicArgs{
			Name: pulumi.String("topic"),
		})
		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.cloudrun.Service;
import com.pulumi.gcp.cloudrun.ServiceArgs;
import com.pulumi.gcp.cloudrun.inputs.ServiceMetadataArgs;
import com.pulumi.gcp.cloudrun.inputs.ServiceTemplateArgs;
import com.pulumi.gcp.cloudrun.inputs.ServiceTemplateSpecArgs;
import com.pulumi.gcp.cloudrun.inputs.ServiceTrafficArgs;
import com.pulumi.gcp.eventarc.Trigger;
import com.pulumi.gcp.eventarc.TriggerArgs;
import com.pulumi.gcp.eventarc.inputs.TriggerMatchingCriteriaArgs;
import com.pulumi.gcp.eventarc.inputs.TriggerDestinationArgs;
import com.pulumi.gcp.eventarc.inputs.TriggerDestinationCloudRunServiceArgs;
import com.pulumi.gcp.pubsub.Topic;
import com.pulumi.gcp.pubsub.TopicArgs;
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 Service("default", ServiceArgs.builder()
            .name("eventarc-service")
            .location("europe-west1")
            .metadata(ServiceMetadataArgs.builder()
                .namespace("my-project-name")
                .build())
            .template(ServiceTemplateArgs.builder()
                .spec(ServiceTemplateSpecArgs.builder()
                    .containers(ServiceTemplateSpecContainerArgs.builder()
                        .image("gcr.io/cloudrun/hello")
                        .ports(ServiceTemplateSpecContainerPortArgs.builder()
                            .containerPort(8080)
                            .build())
                        .build())
                    .containerConcurrency(50)
                    .timeoutSeconds(100)
                    .build())
                .build())
            .traffics(ServiceTrafficArgs.builder()
                .percent(100)
                .latestRevision(true)
                .build())
            .build());
        var primary = new Trigger("primary", TriggerArgs.builder()
            .name("name")
            .location("europe-west1")
            .matchingCriterias(TriggerMatchingCriteriaArgs.builder()
                .attribute("type")
                .value("google.cloud.pubsub.topic.v1.messagePublished")
                .build())
            .destination(TriggerDestinationArgs.builder()
                .cloudRunService(TriggerDestinationCloudRunServiceArgs.builder()
                    .service(default_.name())
                    .region("europe-west1")
                    .build())
                .build())
            .labels(Map.of("foo", "bar"))
            .build());
        var foo = new Topic("foo", TopicArgs.builder()
            .name("topic")
            .build());
    }
}
Content copied to clipboard
resources:
  primary:
    type: gcp:eventarc:Trigger
    properties:
      name: name
      location: europe-west1
      matchingCriterias:
        - attribute: type
          value: google.cloud.pubsub.topic.v1.messagePublished
      destination:
        cloudRunService:
          service: ${default.name}
          region: europe-west1
      labels:
        foo: bar
  foo:
    type: gcp:pubsub:Topic
    properties:
      name: topic
  default:
    type: gcp:cloudrun:Service
    properties:
      name: eventarc-service
      location: europe-west1
      metadata:
        namespace: my-project-name
      template:
        spec:
          containers:
            - image: gcr.io/cloudrun/hello
              ports:
                - containerPort: 8080
          containerConcurrency: 50
          timeoutSeconds: 100
      traffics:
        - percent: 100
          latestRevision: true
Content copied to clipboard

Import

Trigger can be imported using any of these accepted formats:

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

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

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

$ pulumi import gcp:eventarc/trigger:Trigger default projects/{{project}}/locations/{{location}}/triggers/{{name}}
Content copied to clipboard
$ pulumi import gcp:eventarc/trigger:Trigger default {{project}}/{{location}}/{{name}}
Content copied to clipboard
$ pulumi import gcp:eventarc/trigger:Trigger default {{location}}/{{name}}
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(channel: Output<String>? = null, destination: Output<TriggerDestinationArgs>? = null, eventDataContentType: Output<String>? = null, labels: Output<Map<String, String>>? = null, location: Output<String>? = null, matchingCriterias: Output<List<TriggerMatchingCriteriaArgs>>? = null, name: Output<String>? = null, project: Output<String>? = null, serviceAccount: Output<String>? = null, transport: Output<TriggerTransportArgs>? = null)

Properties

Link copied to clipboard
val channel: Output<String>? = null

Optional. The name of the channel associated with the trigger in projects/{project}/locations/{location}/channels/{channel} format. You must provide a channel to receive events from Eventarc SaaS partners.

Link copied to clipboard
val destination: Output<TriggerDestinationArgs>? = null

Required. Destination specifies where the events should be sent to.

Link copied to clipboard
val eventDataContentType: Output<String>? = null

Optional. EventDataContentType specifies the type of payload in MIME format that is expected from the CloudEvent data field. This is set to application/json if the value is not defined.

Link copied to clipboard
val labels: Output<Map<String, String>>? = null

Optional. User labels attached to the triggers that can be used to group resources. Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effective_labels for all of the labels present on the resource.

Link copied to clipboard
val location: Output<String>? = null

The location for the resource

Link copied to clipboard
val matchingCriterias: Output<List<TriggerMatchingCriteriaArgs>>? = null

Required. null The list of filters that applies to event attributes. Only events that match all the provided filters will be sent to the destination.

Link copied to clipboard
val name: Output<String>? = null

Required. The resource name of the trigger. Must be unique within the location on the project.

Link copied to clipboard
val project: Output<String>? = null

The project for the resource

Link copied to clipboard
val serviceAccount: Output<String>? = null

Optional. The IAM service account email associated with the trigger. The service account represents the identity of the trigger. The principal who calls this API must have iam.serviceAccounts.actAs permission in the service account. See https://cloud.google.com/iam/docs/understanding-service-accounts#sa_common for more information. For Cloud Run destinations, this service account is used to generate identity tokens when invoking the service. See https://cloud.google.com/run/docs/triggering/pubsub-push#create-service-account for information on how to invoke authenticated Cloud Run services. In order to create Audit Log triggers, the service account should also have roles/eventarc.eventReceiver IAM role.

Link copied to clipboard
val transport: Output<TriggerTransportArgs>? = null

Optional. In order to deliver messages, Eventarc may use other GCP products as transport intermediary. This field contains a reference to that transport intermediary. This information can be used for debugging purposes.

Functions

Link copied to clipboard
open override fun toJava(): TriggerArgs