Installing Knative Eventing using YAML files

    Before installing Knative, you must meet the following prerequisites:

    • For prototyping purposes, Knative works on most local deployments of Kubernetes. For example, you can use a local, one-node cluster that has 3 CPUs and 4 GB of memory.

      Tip

      You can install a local distribution of Knative for development purposes using the

    • For production purposes, it is recommended that:

      • If you have only one node in your cluster, you need at least 6 CPUs, 6 GB of memory, and 30 GB of disk storage.
      • If you have multiple nodes in your cluster, for each node you need at least 2 CPUs, 4 GB of memory, and 20 GB of disk storage.
      • You have a cluster that uses Kubernetes v1.22 or newer.
      • You have installed the kubectl CLI.
      • Your Kubernetes cluster must have access to the internet, because Kubernetes needs to be able to fetch images. To pull from a private registry, see .

    Caution

    The system requirements provided are recommendations only. The requirements for your installation might vary, depending on whether you use optional components, such as a networking layer.

    Install Knative Eventing

    To install Knative Eventing:

    1. Install the required custom resource definitions (CRDs) by running the command:

    2. Install the core components of Eventing by running the command:

      1. kubectl apply -f https://github.com/knative/eventing/releases/download/knative-v1.7.5/eventing-core.yaml

      Info

      For information about the YAML files in Knative Eventing, see .

    Success

    Monitor the Knative components until all of the components show a STATUS of Running or Completed. You can do this by running the following command and inspecting the output:

    1. kubectl get pods -n knative-eventing

    Example output:

    1. NAME                                   READY   STATUS    RESTARTS   AGE
    2. eventing-controller-7995d654c7-qg895   1/1     Running   0          2m18s
    3. eventing-webhook-fff97b47c-8hmt8       1/1     Running   0          2m17s

    Optional: Install a default Channel (messaging) layer

    The following tabs expand to show instructions for installing a default Channel layer. Follow the procedure for the Channel of your choice:

    Apache Kafka ChannelIn-Memory (standalone)NATS Channel

    The following commands install the KafkaChannel and run event routing in a system namespace. The knative-eventing namespace is used by default.

    1. Install the Kafka controller by running the following command:

      1. kubectl apply -f https://github.com/knative-sandbox/eventing-kafka-broker/releases/download/knative-v1.7.6/eventing-kafka-controller.yaml

    2. Install the KafkaChannel data plane by running the following command:

      1. kubectl apply -f https://github.com/knative-sandbox/eventing-kafka-broker/releases/download/knative-v1.7.6/eventing-kafka-channel.yaml
      1. kubectl apply -f https://github.com/knative-sandbox/eventing-kafka-broker/releases/download/knative-v1.7.6/eventing-kafka-post-install.yaml

    Warning

    This simple standalone implementation runs in-memory and is not suitable for production use cases.

    • Install an in-memory implementation of Channel by running the command:

      1. kubectl apply -f https://github.com/knative/eventing/releases/download/knative-v1.7.5/in-memory-channel.yaml

    1. Install NATS Streaming for Kubernetes.

    2. Install the NATS Streaming Channel by running the command:

    You can change the default channel implementation by following the instructions described in the section.

    The following tabs expand to show instructions for installing the Broker layer. Follow the procedure for the Broker of your choice:

    Apache Kafka BrokerMT-Channel-basedRabbitMQ Broker

    The following commands install the Apache Kafka Broker and run event routing in a system namespace. The knative-eventing namespace is used by default.

    1. Install the Kafka controller by running the following command:

      1. kubectl apply -f https://github.com/knative-sandbox/eventing-kafka-broker/releases/download/knative-v1.7.6/eventing-kafka-controller.yaml

    2. Install the Kafka Broker data plane by running the following command:

      1. kubectl apply -f https://github.com/knative-sandbox/eventing-kafka-broker/releases/download/knative-v1.7.6/eventing-kafka-broker.yaml

    For more information, see the documentation.

    This implementation of Broker uses Channels and runs event routing components in a system namespace, providing a smaller and simpler installation.

    • Install this implementation of Broker by running the command:

      1. kubectl apply -f https://github.com/knative/eventing/releases/download/knative-v1.7.5/mt-channel-broker.yaml

      To customize which Broker Channel implementation is used, update the following ConfigMap to specify which configurations are used for which namespaces:

      1. apiVersion: v1
      2. kind: ConfigMap
      3. metadata:
      4.   name: config-br-defaults
      5.   namespace: knative-eventing
      6. data:
      7.   default-br-config: |
      9.     clusterDefault:
      10.       brokerClass: MTChannelBasedBroker
      11.       apiVersion: v1
      12.       kind: ConfigMap
      13.       name: imc-channel
      14.       namespace: knative-eventing
      15.     # This allows you to specify different defaults per-namespace,
      16.     # in this case the "some-namespace" namespace will use the Kafka
      17.     # channel ConfigMap by default (only for example, you will need
      18.     # to install kafka also to make use of this).
      19.     namespaceDefaults:
      20.       some-namespace:
      21.         brokerClass: MTChannelBasedBroker
      22.         apiVersion: v1
      23.         kind: ConfigMap
      24.         name: kafka-channel
      25.         namespace: knative-eventing

      The referenced imc-channel and kafka-channel example ConfigMaps would look like:

      1. apiVersion: v1
      2. kind: ConfigMap
      3. metadata:
      4.   name: imc-channel
      5.   namespace: knative-eventing
      6. data:
      7.     apiVersion: messaging.knative.dev/v1
      8.     kind: InMemoryChannel
      9. ---
      10. apiVersion: v1
      11. kind: ConfigMap
      12. metadata:
      13.   name: kafka-channel
      14.   namespace: knative-eventing
      15. data:
      16.   channel-template-spec: |
      17.     apiVersion: messaging.knative.dev/v1alpha1
      18.     kind: KafkaChannel
      19.     spec:
      20.       numPartitions: 3
      21.       replicationFactor: 1

    Warning

    In order to use the KafkaChannel, ensure that it is installed on your cluster, as mentioned previously in this topic.

    For more information, see the in GitHub.

    Install optional Eventing extensions

    Apache Kafka SinkSugar ControllerGitHub SourceApache Kafka SourceApache CouchDB SourceVMware Sources and Bindings

    1. Install the Kafka controller by running the command:

      1. kubectl apply -f https://github.com/knative-sandbox/eventing-kafka-broker/releases/download/knative-v1.7.6/eventing-kafka-controller.yaml

    2. Install the Kafka Sink data plane by running the command:

    For more information, see the documentation.

    1. Install the Eventing Sugar Controller by running the command:

      1. kubectl apply -f https://github.com/knative/eventing/releases/download/knative-v1.7.5/eventing-sugar-controller.yaml

      The Knative Eventing Sugar Controller reacts to special labels and annotations and produce Eventing resources. For example:

      • When a namespace is labeled with eventing.knative.dev/injection=enabled, the controller creates a default Broker in that namespace.
      • When a Trigger is annotated with eventing.knative.dev/injection=enabled, the controller creates a Broker named by that Trigger in the Trigger’s namespace.

    2. Enable the default Broker on a namespace (here default) by running the command:

      1. kubectl label namespace <namespace-name> eventing.knative.dev/injection=enabled

      Where <namespace-name> is the name of the namespace.

    A single-tenant GitHub source creates one Knative service per GitHub source.

    A multi-tenant GitHub source only creates one Knative Service, which handles all GitHub sources in the cluster. This source does not support logging or tracing configuration.

    • To install a single-tenant GitHub source run the command:

      1. kubectl apply -f https://github.com/knative-sandbox/eventing-github/releases/download/knative-v1.7.0/github.yaml

    • To install a multi-tenant GitHub source run the command:

      1. kubectl apply -f https://github.com/knative-sandbox/eventing-github/releases/download/knative-v1.7.0/mt-github.yaml

    To learn more, try the GitHub source sample

    1. Install the Apache Kafka Source by running the command:

      1. kubectl apply -f https://github.com/knative-sandbox/eventing-kafka-broker/releases/download/knative-v1.7.6/eventing-kafka-source.yaml

    2. If you’re upgrading from the previous version, run the following command:

    To learn more, try the .

    • Install the Apache CouchDB Source by running the command:

      To learn more, read the Apache CouchDB source documentation.

      • Install VMware Sources and Bindings by running the command:

      To learn more, try the .