Knative

Knative Skill

Overview

Knative is an open-source Kubernetes-based platform for deploying and managing serverless workloads. It provides three main components:

Current Version: v1.20.0 (as of late 2024)

When to Use This Skill

Use this skill when the user:

• Wants to deploy serverless workloads on Kubernetes
• Needs scale-to-zero autoscaling capabilities
• Is implementing event-driven architectures
• Needs traffic management (blue-green, canary, gradual rollout)
• Works with CloudEvents or event routing
• Mentions Knative Serving, Eventing, or Functions
• Asks about Brokers, Triggers, Sources, or Sinks
• Needs to configure networking layers (Kourier, Istio, Contour)

Quick Reference

Knative Service (Serving)

apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: my-service
  namespace: default
spec:
  template:
    metadata:
      annotations:
        # Autoscaling configuration
        autoscaling.knative.dev/class: kpa.autoscaling.knative.dev
        autoscaling.knative.dev/min-scale: "0"
        autoscaling.knative.dev/max-scale: "10"
        autoscaling.knative.dev/target: "100"  # concurrent requests
    spec:
      containers:
        - image: gcr.io/my-project/my-app:latest
          ports:
            - containerPort: 8080
          resources:
            requests:
              cpu: 100m
              memory: 128Mi
            limits:
              memory: 128Mi  # Memory limit = request (required)
          # NO CPU limits (causes throttling)

Traffic Splitting

apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: my-service
spec:
  template:
    # ... container spec
  traffic:
    # Blue-green: 100% to new or old
    - revisionName: my-service-00001
      percent: 90
    - revisionName: my-service-00002
      percent: 10
    # Or use latestRevision
    - latestRevision: true
      percent: 100

Tagged Revisions (Preview URLs)

traffic:
  - revisionName: my-service-00002
    percent: 0
    tag: staging  # Accessible at staging-my-service.example.com
  - latestRevision: true
    percent: 100
    tag: production

Broker and Trigger (Eventing)

# Create a Broker
apiVersion: eventing.knative.dev/v1
kind: Broker
metadata:
  name: default
  namespace: default
---
# Create a Trigger to route events
apiVersion: eventing.knative.dev/v1
kind: Trigger
metadata:
  name: my-trigger
  namespace: default
spec:
  broker: default
  filter:
    attributes:
      type: dev.knative.example
      source: /my/source
  subscriber:
    ref:
      apiVersion: serving.knative.dev/v1
      kind: Service
      name: my-service

Event Source Example (PingSource)

apiVersion: sources.knative.dev/v1
kind: PingSource
metadata:
  name: cron-job
spec:
  schedule: "*/1 * * * *"  # Every minute
  contentType: application/json
  data: '{"message": "Hello from cron"}'
  sink:
    ref:
      apiVersion: serving.knative.dev/v1
      kind: Service
      name: event-display

Installation

Prerequisites

• Kubernetes cluster v1.28+
• kubectl configured
• Cluster admin permissions

Method 1: YAML Install (Recommended for GitOps)

# Install Knative Serving CRDs and Core
kubectl apply -f https://github.com/knative/serving/releases/download/knative-v1.20.0/serving-crds.yaml
kubectl apply -f https://github.com/knative/serving/releases/download/knative-v1.20.0/serving-core.yaml

# Install Networking Layer (choose one)
# Option A: Kourier (lightweight, recommended for most cases)
kubectl apply -f https://github.com/knative/net-kourier/releases/download/knative-v1.20.0/kourier.yaml
kubectl patch configmap/config-network \
  --namespace knative-serving \
  --type merge \
  --patch '{"data":{"ingress-class":"kourier.ingress.networking.knative.dev"}}'

# Option B: Istio (for service mesh requirements)
kubectl apply -f https://github.com/knative/net-istio/releases/download/knative-v1.20.0/net-istio.yaml

# Install Knative Eventing
kubectl apply -f https://github.com/knative/eventing/releases/download/knative-v1.20.0/eventing-crds.yaml
kubectl apply -f https://github.com/knative/eventing/releases/download/knative-v1.20.0/eventing-core.yaml

# Install In-Memory Channel (dev only) or Kafka Channel (production)
kubectl apply -f https://github.com/knative/eventing/releases/download/knative-v1.20.0/in-memory-channel.yaml

# Install MT-Channel-Based Broker
kubectl apply -f https://github.com/knative/eventing/releases/download/knative-v1.20.0/mt-channel-broker.yaml

Method 2: Knative Operator

# Install the Operator
kubectl apply -f https://github.com/knative/operator/releases/download/knative-v1.20.0/operator.yaml

# Deploy Knative Serving
apiVersion: operator.knative.dev/v1beta1
kind: KnativeServing
metadata:
  name: knative-serving
  namespace: knative-serving
spec:
  ingress:
    kourier:
      enabled: true
  config:
    network:
      ingress-class: kourier.ingress.networking.knative.dev

---
# Deploy Knative Eventing
apiVersion: operator.knative.dev/v1beta1
kind: KnativeEventing
metadata:
  name: knative-eventing
  namespace: knative-eventing

Configure DNS

# Get the External IP of the ingress
kubectl get svc kourier -n kourier-system

# Option A: Real DNS (production)
# Create A record: *.knative.example.com -> EXTERNAL-IP

# Option B: Magic DNS with sslip.io (development)
kubectl patch configmap/config-domain \
  --namespace knative-serving \
  --type merge \
  --patch '{"data":{"<EXTERNAL-IP>.sslip.io":""}}'

# Option C: Default domain (internal only)
kubectl patch configmap/config-domain \
  --namespace knative-serving \
  --type merge \
  --patch '{"data":{"example.com":""}}'

Autoscaling

Autoscaler Classes

Autoscaling Annotations

metadata:
  annotations:
    # Autoscaler class
    autoscaling.knative.dev/class: kpa.autoscaling.knative.dev

    # Scale bounds
    autoscaling.knative.dev/min-scale: "1"    # Prevent scale-to-zero
    autoscaling.knative.dev/max-scale: "100"
    autoscaling.knative.dev/initial-scale: "3"

    # Scaling metric (KPA)
    autoscaling.knative.dev/metric: concurrency  # or rps
    autoscaling.knative.dev/target: "100"        # target per pod

    # Scale-down behavior
    autoscaling.knative.dev/scale-down-delay: "5m"
    autoscaling.knative.dev/scale-to-zero-pod-retention-period: "1m"

    # Window for averaging metrics
    autoscaling.knative.dev/window: "60s"

Concurrency Limits

spec:
  template:
    spec:
      containerConcurrency: 100  # Hard limit per pod (0 = unlimited)

Networking

Networking Layer Comparison

TLS Configuration

# Using cert-manager (recommended)
apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: my-service
  annotations:
    # Auto-TLS with cert-manager
    networking.knative.dev/certificate-class: cert-manager
spec:
  # ... template spec

Custom Domain Mapping

apiVersion: serving.knative.dev/v1beta1
kind: DomainMapping
metadata:
  name: api.example.com
  namespace: default
spec:
  ref:
    kind: Service
    name: my-service
    apiVersion: serving.knative.dev/v1

Eventing Patterns

Event Source Types

Channel Types

Sequence (Chained Processing)

apiVersion: flows.knative.dev/v1
kind: Sequence
metadata:
  name: my-sequence
spec:
  channelTemplate:
    apiVersion: messaging.knative.dev/v1
    kind: InMemoryChannel
  steps:
    - ref:
        apiVersion: serving.knative.dev/v1
        kind: Service
        name: step-1
    - ref:
        apiVersion: serving.knative.dev/v1
        kind: Service
        name: step-2
  reply:
    ref:
      apiVersion: serving.knative.dev/v1
      kind: Service
      name: final-handler

Parallel (Fan-out)

apiVersion: flows.knative.dev/v1
kind: Parallel
metadata:
  name: my-parallel
spec:
  channelTemplate:
    apiVersion: messaging.knative.dev/v1
    kind: InMemoryChannel
  branches:
    - subscriber:
        ref:
          apiVersion: serving.knative.dev/v1
          kind: Service
          name: handler-a
    - subscriber:
        ref:
          apiVersion: serving.knative.dev/v1
          kind: Service
          name: handler-b

Knative Functions

CLI Installation

# macOS
brew install knative/client/func

# Linux
curl -sL https://github.com/knative/func/releases/latest/download/func_linux_amd64 -o func
chmod +x func && sudo mv func /usr/local/bin/

Function Lifecycle

# Create a new function
func create -l python my-function
cd my-function

# Build the function
func build

# Deploy to cluster
func deploy

# Invoke locally
func invoke

# Invoke remote
func invoke --target=remote

Supported Languages

Function Configuration (func.yaml)

specVersion: 0.36.0
name: my-function
runtime: python
registry: docker.io/myuser
image: docker.io/myuser/my-function:latest
build:
  builder: pack
  buildpacks:
    - paketo-buildpacks/python
deploy:
  namespace: default
  annotations:
    autoscaling.knative.dev/min-scale: "1"
  env:
    - name: MY_VAR
      value: my-value
  volumes:
    - secret: my-secret
      path: /secrets

Best Practices

Resource Configuration

resources:
  requests:
    cpu: 100m
    memory: 128Mi
  limits:
    memory: 128Mi  # Same as request
    # NO cpu limit!

Probes Configuration

spec:
  containers:
    - image: my-app
      readinessProbe:
        httpGet:
          path: /health
          port: 8080
        initialDelaySeconds: 5
        periodSeconds: 10
      # Liveness probe optional for serverless
      # (Knative handles pod lifecycle)

Cold Start Optimization

1. Keep minimum replicas: Set min-scale: "1" for latency-critical services 2. Optimize container image: Use distroless/alpine base images 3. Lazy initialization: Defer heavy initialization until first request 4. Connection pooling: Pre-warm database connections

Production Checklist

• [ ] Use KafkaChannel instead of InMemoryChannel
• [ ] Configure proper resource requests/limits
• [ ] Set up TLS with cert-manager
• [ ] Configure custom domain
• [ ] Set appropriate min/max scale values
• [ ] Enable dead letter sink for Triggers
• [ ] Configure monitoring (Prometheus metrics)
• [ ] Set up proper RBAC

Troubleshooting

Common Issues

Diagnostic Commands

# Check Knative Serving status
kubectl get ksvc -A
kubectl describe ksvc <service-name>

# Check revisions
kubectl get revisions -A
kubectl describe revision <revision-name>

# Check routes
kubectl get routes -A

# Check Knative Eventing status
kubectl get brokers -A
kubectl get triggers -A
kubectl get sources -A

# Check event delivery
kubectl get subscriptions -A

# View activator logs
kubectl logs -n knative-serving -l app=activator -c activator

# View controller logs
kubectl logs -n knative-serving -l app=controller

# Check networking layer (Kourier)
kubectl logs -n kourier-system -l app=3scale-kourier-gateway

Debug Event Flow

# Deploy event-display service for debugging
kubectl apply -f - <<EOF
apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: event-display
spec:
  template:
    spec:
      containers:
        - image: gcr.io/knative-releases/knative.dev/eventing/cmd/event_display
EOF

# Create a trigger to route all events
kubectl apply -f - <<EOF
apiVersion: eventing.knative.dev/v1
kind: Trigger
metadata:
  name: debug-trigger
spec:
  broker: default
  subscriber:
    ref:
      apiVersion: serving.knative.dev/v1
      kind: Service
      name: event-display
EOF

# Watch events
kubectl logs -l serving.knative.dev/service=event-display -c user-container -f

Integration with ArgoCD

ApplicationSet for Knative Services

apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: knative-services
spec:
  generators:
    - git:
        repoURL: https://github.com/org/repo.git
        revision: HEAD
        directories:
          - path: knative-services/*
  template:
    metadata:
      name: '{{path.basename}}'
      annotations:
        # Disable SSA if using Jobs
        argocd.argoproj.io/compare-options: ServerSideDiff=false
    spec:
      project: default
      source:
        repoURL: https://github.com/org/repo.git
        targetRevision: HEAD
        path: '{{path}}'
      destination:
        server: https://kubernetes.default.svc
        namespace: default
      syncPolicy:
        automated:
          prune: true
          selfHeal: true

Health Checks for Knative Resources

ArgoCD automatically recognizes Knative resources. Custom health checks:

# In argocd-cm ConfigMap
data:
  resource.customizations.health.serving.knative.dev_Service: |
    hs = {}
    if obj.status ~= nil then
      if obj.status.conditions ~= nil then
        for _, condition in ipairs(obj.status.conditions) do
          if condition.type == "Ready" and condition.status == "True" then
            hs.status = "Healthy"
            hs.message = "Service is ready"
            return hs
          end
        end
      end
    end
    hs.status = "Progressing"
    hs.message = "Waiting for service to be ready"
    return hs

References

• Official Documentation
• Knative Serving API
• Knative Eventing API
• Knative Functions
• GitHub Repository
• Detailed Reference

---

Gotchas

• `min-scale: "0"` saves money but cold-start hits the first request — sometimes 3-10s for JVM/Python apps. Health probes hitting the public URL accidentally keep the pod warm; removing them surfaces the cold-start the user always had.
• `containerConcurrency: 0` (unlimited) breaks KPA autoscaling because the autoscaler has no concurrency target to scale against. Always set an explicit value; the default 0 silently disables proper scaling.
• Knative Service `spec.template.metadata.name` is immutable once set — changing it doesn't create a new revision, it fails the apply. Omit the name and let Knative generate -00001, -00002, etc.
• `ServerSideDiff=false` annotation is required on ArgoCD apps deploying Knative Services because ArgoCD's schema doesn't recognize Knative status fields. Without it, syncs fail with field not declared in schema even when manifests are valid.
• InMemoryChannel loses events on broker pod restart — fine for dev, catastrophic for prod. Symptom: triggers report Ready=True but events sporadically vanish. Always use KafkaChannel or NATSChannel in production.
• CPU limits cause request latency spikes during scale-from-zero because the activator throttles. Match the cluster policy: requests only, no CPU limits.
• Tagged revisions with `percent: 0` still receive traffic on the <tag>-<service> subdomain, even if the main route shows 0%. Don't assume tag=0 means "no traffic".

Knative Detailed Reference

API Reference

Serving API (serving.knative.dev/v1)

Service

The primary resource for deploying serverless workloads.

apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: string                    # Required: Unique name
  namespace: string               # Optional: defaults to 'default'
  labels: {}                      # Optional: Key-value labels
  annotations:                    # Optional: Key-value annotations
    # Common annotations
    serving.knative.dev/creator: string
    serving.knative.dev/lastModifier: string
spec:
  template:                       # Required: PodTemplateSpec
    metadata:
      name: string                # Optional: Revision name (auto-generated if omitted)
      annotations:                # Autoscaling and other annotations
        autoscaling.knative.dev/class: string
        autoscaling.knative.dev/metric: string
        autoscaling.knative.dev/target: string
        autoscaling.knative.dev/min-scale: string
        autoscaling.knative.dev/max-scale: string
    spec:
      serviceAccountName: string  # Optional: Service account
      containerConcurrency: int   # Optional: Hard concurrency limit (0=unlimited)
      timeoutSeconds: int         # Optional: Request timeout (default: 300)
      containers:                 # Required: Container specs
        - name: string
          image: string           # Required: Container image
          imagePullPolicy: string # Optional: Always/IfNotPresent/Never
          command: []             # Optional: Entrypoint
          args: []                # Optional: Arguments
          env: []                 # Optional: Environment variables
          envFrom: []             # Optional: Environment from ConfigMap/Secret
          ports:                  # Optional: Container ports
            - name: string        # Optional: h2c or http1
              containerPort: int  # Required: Port number
              protocol: string    # Optional: TCP (default)
          resources:              # Recommended: Resource requirements
            requests:
              cpu: string
              memory: string
            limits:
              memory: string      # CPU limits NOT recommended
          readinessProbe: {}      # Optional: Readiness probe
          livenessProbe: {}       # Optional: Liveness probe
          volumeMounts: []        # Optional: Volume mounts
      volumes: []                 # Optional: Volumes
  traffic:                        # Optional: Traffic routing
    - revisionName: string        # Route to specific revision
      latestRevision: bool        # Or route to latest
      percent: int                # Traffic percentage (0-100)
      tag: string                 # Optional: Named tag for URL

Configuration

Manages revision history (typically managed through Service).

apiVersion: serving.knative.dev/v1
kind: Configuration
metadata:
  name: string
spec:
  template:                       # Same as Service.spec.template
    # ...

Revision

Immutable snapshot of code and configuration (auto-created).

apiVersion: serving.knative.dev/v1
kind: Revision
metadata:
  name: string                    # Auto-generated: {service}-{random}
  labels:
    serving.knative.dev/service: string
    serving.knative.dev/configuration: string
spec:
  # Inherited from Configuration/Service template

Route

Manages traffic routing to Revisions.

apiVersion: serving.knative.dev/v1
kind: Route
metadata:
  name: string
spec:
  traffic:
    - revisionName: string
      percent: int
      tag: string

Eventing API (eventing.knative.dev/v1)

Broker

Event routing hub.

apiVersion: eventing.knative.dev/v1
kind: Broker
metadata:
  name: string
  namespace: string
  annotations:
    eventing.knative.dev/broker.class: string  # MTChannelBasedBroker, Kafka, etc.
spec:
  config:                         # Optional: Broker configuration
    apiVersion: string
    kind: string
    name: string
    namespace: string
  delivery:                       # Optional: Delivery options
    deadLetterSink:               # Dead letter queue
      ref:
        apiVersion: string
        kind: string
        name: string
    retry: int                    # Retry count
    backoffPolicy: string         # linear or exponential
    backoffDelay: string          # Duration (e.g., PT1S)

Trigger

Event subscription with filtering.

apiVersion: eventing.knative.dev/v1
kind: Trigger
metadata:
  name: string
  namespace: string
spec:
  broker: string                  # Required: Broker name
  filter:                         # Optional: Event filtering
    attributes:                   # CloudEvent attributes
      type: string                # Event type filter
      source: string              # Event source filter
      subject: string             # Event subject filter
      # Any CloudEvent extension attribute
  subscriber:                     # Required: Event destination
    ref:                          # Reference to Kubernetes resource
      apiVersion: string
      kind: string
      name: string
      namespace: string           # Optional: defaults to Trigger namespace
    uri: string                   # Alternative: Direct URI
  delivery:                       # Optional: Per-trigger delivery options
    deadLetterSink: {}
    retry: int
    backoffPolicy: string
    backoffDelay: string

Sources API (sources.knative.dev/v1)

PingSource

Cron-scheduled event producer.

apiVersion: sources.knative.dev/v1
kind: PingSource
metadata:
  name: string
spec:
  schedule: string                # Required: Cron expression
  timezone: string                # Optional: Timezone (default: UTC)
  contentType: string             # Optional: application/json, text/plain
  data: string                    # Optional: Event payload
  dataBase64: string              # Optional: Base64-encoded payload
  sink:                           # Required: Event destination
    ref:
      apiVersion: string
      kind: string
      name: string
    uri: string                   # Alternative: Direct URI

ApiServerSource

Kubernetes API event producer.

apiVersion: sources.knative.dev/v1
kind: ApiServerSource
metadata:
  name: string
spec:
  mode: string                    # Reference or Resource
  resources:                      # Required: Resources to watch
    - apiVersion: string
      kind: string
  serviceAccountName: string      # Required: SA with RBAC permissions
  sink:
    ref:
      apiVersion: string
      kind: string
      name: string

ContainerSource

Custom container event producer.

apiVersion: sources.knative.dev/v1
kind: ContainerSource
metadata:
  name: string
spec:
  template:                       # Required: Pod template
    spec:
      containers:
        - image: string
          name: string
          env:
            - name: K_SINK        # Injected by Knative
              value: string
  sink:
    ref:
      apiVersion: string
      kind: string
      name: string

Flows API (flows.knative.dev/v1)

Sequence

Serial event processing pipeline.

apiVersion: flows.knative.dev/v1
kind: Sequence
metadata:
  name: string
spec:
  channelTemplate:                # Required: Channel type
    apiVersion: messaging.knative.dev/v1
    kind: InMemoryChannel         # Or KafkaChannel
  steps:                          # Required: Processing steps
    - ref:
        apiVersion: string
        kind: string
        name: string
      uri: string                 # Alternative to ref
      delivery: {}                # Optional: Per-step delivery
  reply:                          # Optional: Final destination
    ref:
      apiVersion: string
      kind: string
      name: string

Parallel

Fan-out event processing.

apiVersion: flows.knative.dev/v1
kind: Parallel
metadata:
  name: string
spec:
  channelTemplate:
    apiVersion: messaging.knative.dev/v1
    kind: InMemoryChannel
  branches:                       # Required: Parallel branches
    - filter:                     # Optional: Branch filter
        ref:
          apiVersion: string
          kind: string
          name: string
      subscriber:                 # Required: Branch processor
        ref:
          apiVersion: string
          kind: string
          name: string
      reply:                      # Optional: Branch reply destination
        ref:
          apiVersion: string
          kind: string
          name: string
  reply:                          # Optional: Aggregated reply destination
    ref:
      apiVersion: string
      kind: string
      name: string

ConfigMaps Reference

config-autoscaler (knative-serving)

apiVersion: v1
kind: ConfigMap
metadata:
  name: config-autoscaler
  namespace: knative-serving
data:
  # Container concurrency target default
  container-concurrency-target-default: "100"

  # Target utilization (0.0-1.0)
  target-utilization-percentage: "70"

  # Scale bounds
  enable-scale-to-zero: "true"
  scale-to-zero-grace-period: "30s"
  scale-to-zero-pod-retention-period: "0s"

  # Scaling rates
  max-scale-up-rate: "1000"
  max-scale-down-rate: "2"

  # Stable window for metrics
  stable-window: "60s"

  # Panic mode settings
  panic-window-percentage: "10"
  panic-threshold-percentage: "200"

config-defaults (knative-serving)

apiVersion: v1
kind: ConfigMap
metadata:
  name: config-defaults
  namespace: knative-serving
data:
  # Default revision timeout
  revision-timeout-seconds: "300"

  # Default container concurrency
  container-concurrency: "0"

  # Default resource requests
  revision-cpu-request: "400m"
  revision-memory-request: "100M"
  revision-ephemeral-storage-request: "500M"

  # Default resource limits
  revision-cpu-limit: "1000m"
  revision-memory-limit: "200M"
  revision-ephemeral-storage-limit: "750M"

config-domain (knative-serving)

apiVersion: v1
kind: ConfigMap
metadata:
  name: config-domain
  namespace: knative-serving
data:
  # Default domain for all services
  example.com: ""

  # Selector-based domain mapping
  custom.example.com: |
    selector:
      app: special-app

config-network (knative-serving)

apiVersion: v1
kind: ConfigMap
metadata:
  name: config-network
  namespace: knative-serving
data:
  # Ingress class (networking layer)
  ingress-class: kourier.ingress.networking.knative.dev
  # Or: istio.ingress.networking.knative.dev
  # Or: contour.ingress.networking.knative.dev

  # Certificate class for auto-TLS
  certificate-class: cert-manager.certificate.networking.knative.dev

  # Auto-TLS configuration
  auto-tls: "Enabled"
  http-protocol: "Redirected"  # or "Enabled"

  # External/Internal service visibility
  default-external-scheme: https

  # Domain template
  domain-template: "{{.Name}}.{{.Namespace}}.{{.Domain}}"

config-br-defaults (knative-eventing)

apiVersion: v1
kind: ConfigMap
metadata:
  name: config-br-defaults
  namespace: knative-eventing
data:
  default-br-config: |
    clusterDefault:
      brokerClass: MTChannelBasedBroker
      apiVersion: v1
      kind: ConfigMap
      name: config-br-default-channel
      namespace: knative-eventing
      delivery:
        retry: 10
        backoffPolicy: exponential
        backoffDelay: PT0.2S

Metrics Reference

Serving Metrics

Exposed at :9090/metrics on knative-serving pods.

Eventing Metrics

CloudEvents Specification

Knative Eventing uses CloudEvents format (CNCF specification).

Required Attributes

Optional Attributes

HTTP Binding

POST /events HTTP/1.1
Host: broker-ingress.knative-eventing.svc.cluster.local
Content-Type: application/json
ce-specversion: 1.0
ce-type: dev.knative.example
ce-source: /my/source
ce-id: A234-1234-1234
ce-time: 2024-01-01T00:00:00Z

{
  "message": "Hello, World!"
}

Annotations Reference

Serving Annotations

Eventing Annotations

Status Conditions

Service Status

Revision Status

Broker Status

Trigger Status