How do I run event-driven workflows in Kubernetes with Argo Events?

In this guide, we will set up and run event-driven workflows in Kubernetes using Argo Events. Argo Events is an event-driven workflow automation framework for Kubernetes. It allows you to trigger workflows based on events from various sources. We will use Pulumi to define and deploy the necessary Kubernetes resources, including Argo Events components.

Steps

Install Argo Events: We will install the Argo Events controller and event bus.
Create Event Source: Define an event source that will trigger the workflow.
Create Sensor: Define a sensor that listens to the event source and triggers a workflow.
Deploy Workflow: Define and deploy a sample workflow that will be triggered by the sensor.

import * as pulumi from "@pulumi/pulumi";
import * as k8s from "@pulumi/kubernetes";

// Define the namespace for Argo Events
const namespace = new k8s.core.v1.Namespace("argo-events", {
    metadata: { name: "argo-events" },
});

// Install Argo Events components
const argoEventsController = new k8s.helm.v3.Chart("argo-events-controller", {
    chart: "argo-events",
    version: "1.6.1",
    fetchOpts: { repo: "https://argoproj.github.io/argo-helm" },
    namespace: namespace.metadata.name,
});

const eventBus = new k8s.apiextensions.CustomResource("event-bus", {
    apiVersion: "argoproj.io/v1alpha1",
    kind: "EventBus",
    metadata: {
        namespace: namespace.metadata.name,
        name: "default",
    },
    spec: {
        nats: {
            native: {
                replicas: 1,
            },
        },
    },
});

// Define an event source (e.g., webhook)
const webhookEventSource = new k8s.apiextensions.CustomResource("webhook-event-source", {
    apiVersion: "argoproj.io/v1alpha1",
    kind: "EventSource",
    metadata: {
        namespace: namespace.metadata.name,
        name: "webhook",
    },
    spec: {
        service: {
            ports: [{
                port: 12000,
                targetPort: 12000,
            }],
        },
        webhook: {
            example: {
                endpoint: "/",
                method: "POST",
                port: "12000",
            },
        },
    },
}, { dependsOn: [argoEventsController] });

// Define a sensor to listen to the event source and trigger a workflow
const workflowSensor = new k8s.apiextensions.CustomResource("workflow-sensor", {
    apiVersion: "argoproj.io/v1alpha1",
    kind: "Sensor",
    metadata: {
        namespace: namespace.metadata.name,
        name: "workflow-sensor",
    },
    spec: {
        dependencies: [{
            name: "webhook-dep",
            eventSourceName: "webhook",
            eventName: "example",
        }],
        triggers: [{
            template: {
                name: "argo-workflow-trigger",
                argoWorkflow: {
                    source: {
                        resource: {
                            apiVersion: "argoproj.io/v1alpha1",
                            kind: "Workflow",
                            metadata: {
                                generateName: "webhook-triggered-",
                            },
                            spec: {
                                entrypoint: "whalesay",
                                templates: [{
                                    name: "whalesay",
                                    container: {
                                        image: "docker/whalesay",
                                        command: ["cowsay"],
                                        args: ["hello world"],
                                    },
                                }],
                            },
                        },
                    },
                },
            },
        }],
    },
}, { dependsOn: [webhookEventSource] });

Key Points

Namespace: We created a Kubernetes namespace argo-events for organizing Argo Events resources.
Argo Events Controller: Installed the Argo Events controller using a Helm chart.
Event Bus: Defined an event bus using a custom resource.
Event Source: Created a webhook event source that listens for HTTP POST requests.
Sensor: Defined a sensor that triggers a workflow when an event is received from the webhook event source.
Workflow: A simple Argo workflow that runs a cowsay container.

Summary

In this guide, we set up an event-driven workflow in Kubernetes using Argo Events. We used Pulumi to define and deploy the necessary Kubernetes resources, including the Argo Events controller, event bus, event source, and sensor. The sensor listens for events from the webhook event source and triggers a workflow that runs a cowsay container.

Deploy this code

Want to deploy this code? Sign up for a free Pulumi account to deploy in a few clicks.

New to Pulumi?

Want to deploy this code? Sign up with Pulumi to deploy in a few clicks.