Using gcp cloudtasks with eventarc

Question

Pulumi · Accepted Answer

To use Google Cloud Tasks with Eventarc in a Pulumi program, we'll create a system where Cloud Tasks queues are used to schedule tasks, and Eventarc triggers are set up to respond to events in Google Cloud services.

Here's how you can set this up using Pulumi with the GCP provider:

1. **Create a Cloud Tasks queue**: This is a managed queue for asynchronous task execution.
2. **Set up an Eventarc trigger**: This will listen to events from various Google Cloud sources and trigger a specified action, such as invoking a Cloud Run service, a GKE service, or a Cloud Function.
3. **Connect Cloud Tasks with Eventarc**: You can then dispatch tasks to this queue that trigger the Eventarc trigger upon execution.

Below is a program in TypeScript that sets up a Cloud Tasks queue and an Eventarc trigger. It assumes that you already have a Cloud Run service or a Cloud Function in place that you want to trigger via Eventarc.

```typescript
import * as gcp from '@pulumi/gcp';

// Create a Cloud Task Queue in the desired location
const taskQueue = new gcp.cloudtasks.Queue("my-task-queue", {
    location: "us-central1", // Replace with your desired GCP location
    // You can specify additional settings like rateLimits and retryConfig according to your requirements
});

// Eventarc Channel (assuming you want to create a new Eventarc channel)
const eventarcChannel = new gcp.eventarc.Channel("my-eventarc-channel", {
    location: "us-central1", // Replace with your desired GCP location
    // Additional channel configurations can be applied here
});

// Eventarc Trigger to respond to the dispatched tasks
const eventarcTrigger = new gcp.eventarc.Trigger("my-cloud-tasks-trigger", {
    location: "us-central1", // Replace with your desired GCP location
    transport: {
        pubsubTopic: eventarcChannel.id, // Here we connect the Eventarc channel to the trigger
    },
    destination: {
        cloudRunService: {
            service: "my-cloud-run-service", // Replace with your Cloud Run service name
            path: "/tasks", // Replace with the specific path you want to trigger, if necessary
        },
    },
    matchingCriterias: [{
        attribute: "type",
        value: "google.cloud.tasks.v2.Task", // The event type that this trigger is filtering on
    }],
});

export const queueName = taskQueue.name;
export const channelName = eventarcChannel.name;
export const triggerId = eventarcTrigger.id;
```

In this program:

- We use `@pulumi/gcp` to communicate with Google Cloud services.
- A new Cloud Tasks queue is created using `gcp.cloudtasks.Queue`. You should replace the `location` with the region that suits your application.
- An Eventarc channel is set up using `gcp.eventarc.Channel` to accept the events. The channel's location should be in the same region as the Cloud Tasks queue for simplicity.
- An Eventarc trigger is created using `gcp.eventarc.Trigger` to respond to events in the Cloud Tasks queue. The trigger is set to respond to the event type of dispatched tasks (`google.cloud.tasks.v2.Task`).
- Replace `"my-cloud-run-service"` with the name of your cloud service you wish to trigger. If you’re triggering a different service (like a Cloud Function), you'll need to adjust the `destination` block accordingly.
- Finally, we export some of the key properties of these resources so they can be easily referenced, like the names and ID of the queue, channel, and trigger.

You’ll need to ensure that your Cloud Run service, GKE service, or Cloud Function is configured to handle incoming requests from the triggers. This entails setting up the appropriate service to receive HTTPS requests and processing them as needed.