10 KiB

Raw Blame History

Create a SinkBinding

This topic describes how to create a SinkBinding object. SinkBinding resolves a sink as a URI, sets the URI in the environment variable K_SINK, and adds the URI to a subject using K_SINK. If the URI changes, SinkBinding updates the value of K_SINK.

In the following examples, the sink is a Knative Service and the subject is a CronJob. If you have an existing subject and sink, you can replace the examples with your own values.

Before you begin

Before you can create a SinkBinding object:

You must have Knative Eventing installed on your cluster.
Optional: If you want to use kn commands with SinkBinding, install the kn CLI.

Optional: Choose SinkBinding namespace selection behavior

The SinkBinding object operates in one of two modes: exclusion or inclusion.

The default mode is exclusion. In exclusion mode, SinkBinding behavior is enabled for the namespace by default. To disallow a namespace from being evaluated for mutation you must exclude it using the label bindings.knative.dev/exclude: true.

In inclusion mode, SinkBinding behavior is not enabled for the namespace. Before a namespace can be evaluated for mutation, you must explicitly include it using the label bindings.knative.dev/include: true.

To set the SinkBinding object to inclusion mode:

Change the value of SINK_BINDING_SELECTION_MODE from exclusion to inclusion by running:

kubectl -n knative-eventing set env deployments eventing-webhook --containers="eventing-webhook" SINK_BINDING_SELECTION_MODE=inclusion

To verify that SINK_BINDING_SELECTION_MODE is set as desired, run:

kubectl -n knative-eventing set env deployments eventing-webhook --containers="eventing-webhook" --list | grep SINK_BINDING

Create a namespace

If you do not have an existing namespace, create a namespace for the SinkBinding object:

kubectl create namespace <namespace>

Where <namespace> is the namespace that you want your SinkBinding to use. For example, sinkbinding-example.

!!! note If you have selected inclusion mode, you must add the bindings.knative.dev/include: true label to the namespace to enable SinkBinding behavior.

Create a sink

The sink can be any addressable Kubernetes object that can receive events.

If you do not have an existing sink that you want to connect to the SinkBinding object, create a Knative service.

!!! note To create a Knative service you must have Knative Serving installed on your cluster.

=== "kn"

Create a Knative service by running:

```bash
kn service create <app-name> --image <image-url>
```
Where:

- `<app-name>` is the name of the application.
- `<image-url>` is the URL of the image container.

For example:

```bash
$ kn service create event-display --image gcr.io/knative-releases/knative.dev/eventing/cmd/event_display
```

=== "YAML" 1. Create a YAML file for the Knative service using the following template:

    ```yaml
    apiVersion: serving.knative.dev/v1
    kind: Service
    metadata:
      name: <app-name>
    spec:
      template:
        spec:
          containers:
            - image: <image-url>
    ```
    Where:

    - `<app-name>` is the name of the application. For example, `event-display`.
    - `<image-url>` is the URL of the image container.
    For example, `gcr.io/knative-releases/knative.dev/eventing/cmd/event_display`.

1. Apply the YAML file by running the command:

    ```bash
    kubectl apply -f <filename>.yaml
    ```
    Where `<filename>` is the name of the file you created in the previous step.

Create a subject

The subject must be a PodSpecable resource. You can use any PodSpecable resource in your cluster, for example:

Deployment
Job
DaemonSet
StatefulSet
Service.serving.knative.dev

If you do not have an existing PodSpecable subject that you want to use, you can use the following sample to create a CronJob object as the subject. The following CronJob makes a single cloud event that targets K_SINK and adds any extra overrides given by CE_OVERRIDES.

Create a YAML file for the CronJob using the following example:

apiVersion: batch/v1beta1
kind: CronJob
metadata:
  name: heartbeat-cron
spec:
  # Run every minute
  schedule: "*/1 * * * *"
  jobTemplate:
    metadata:
      labels:
        app: heartbeat-cron
    spec:
      template:
        spec:
          restartPolicy: Never
          containers:
            - name: single-heartbeat
              image: gcr.io/knative-releases/knative.dev/eventing-contrib/cmd/heartbeats
              args:
              - --period=1
              env:
                - name: ONE_SHOT
                  value: "true"
                - name: POD_NAME
                  valueFrom:
                    fieldRef:
                      fieldPath: metadata.name
                - name: POD_NAMESPACE
                  valueFrom:
                    fieldRef:
                      fieldPath: metadata.namespace

Apply the YAML file by running the command:
```
kubectl apply -f <filename>.yaml
```
Where <filename> is the name of the file you created in the previous step.