The Console is a web-based administrative UI for Kyma. It allows you to administer the Kyma functionality and manage the basic Kubernetes resources.

The Console uses the Luigi framework to extend the UI functionality with custom micro frontends and bring more functionality to the existing UI. You can define the micro frontends using dedicated CustomResourceDefinitions (CRDs).

Use the following CRs to modify the Console UI:

• The MicroFrontend custom resource allows you to plug in micro frontends for a specific Namespace.
• The ClusterMicroFrontend custom resource allows you to plug in micro frontends for the entire Cluster.
• The BackendModule custom resource allows you to enable Console Backend Service modules.

The Console Backend Service is a backend service which provides an API for all views of the Console UI. This service consumes the Kubernetes API and exposes a simplified GraphQL API to allow frontends to perform Kubernetes resource operations.

NOTE: Read the security document for more information about the Kyma GraphQL implementation.

Cache

For GraphQL queries, the Console Backend Service uses caching which is based on Informers from the Kubernetes Go client. There are separate cache stores for every Kubernetes resource. The stores are synchronized when the service starts. After cache synchronization, a single connection with the Kubernetes API server is established and any event related to one of the observed resources updates the corresponding cache store. This logic ensures that cache stores are always up-to-date without sending multiple requests to the Kubernetes API server.

Modularization

The Console Backend Service consists of the Kubernetes resource logic and cache for different domains, such as the Service Catalog, Application, or Serverless. The Console Backend Service introduces modularization changes which are based on toggling modules while the server is running. The enabled module synchronizes cache for its resource and enables the module's logic for all server requests. If you disable a given module, every GraphQL query, mutation, and subscription related to this module returns an error.

These are the available Console Backend Service pluggable modules which contain the GraphQL resolver logic, where:

• apicontroller relates to the API Controller.
• apigateway relates to the API Gateway.
• authentication relates to IDP Presets.
• application relates to the Application Connector.
• serverless relates to Serverless.
• eventing relates to Knative Eventing.
• rafter relates to Rafter.
• servicecatalog relates to the Service Catalog, including ServiceClasses, ServiceInstances, and ServiceBindings.
• servicecatalogaddons relates to the Service Catalog add-ons, such as ServiceBindingUsage, and UsageKinds.
• grafana relates to Grafana.
• loki relates to Loki.

To enable a given module, install the corresponding Kyma component. It includes the BackendModule custom resource with the same name as the name of a given module.

For security reasons, follow the listed guidelines when you configure the web server for the MicroFrontend or ClusterMicroFrontend:

• Make the MicroFrontend or ClusterMicroFrontend accessible only through HTTPS.
• Make the Access-Control-Allow-Origin HTTP header as restrictive as possible.
• Set the X-Content-Type HTTP header to nosniff.
• Set the X-Frame-Options HTTP header to sameorigin or allow-from ALLOWED_URL.
• Add Content Security Policies (CSPs).

Rafter in Kyma is a separate component and does not provide templates or a standalone UI to display content from the CMS. Still, the Console UI displays some of the assets under the Service Catalog view (API specifications and Service Class-related documentation).

Add a new API specification or Service Class-related documentation topic to the Console UI by creating a CR, while Rafter handles the rest. Define the location, grouping, and order of the documents through AssetGroup and ClusterAssetGroup labels that you add to the custom resource definition. You can create your own labels and follow your own naming convention, but rafter.kyma-project.io/{label-name} applies to the Console UI.

Use the rafter.kyma-project.io/view-context label to mark and filter Service Class-related assets in the Console UI. Set its value to service-catalog to specify that these assets should be displayed under the Service Catalog view.

Configuration

To define how AssetGroup and ClusterAssetGroup are rendered in the UI, use the following parameters:

Supported specifications

The Console UI supports only certain specification types, formats, and versions passed in the AssetGroups and ClusterAssetGroups:

NOTE: OpenAPI, OData, and AsyncAPI specifications rendered in the Console UI follow the Fiori 3 Fundamentals styling standards.

The source files are uploaded directly to the given storage without any modifications, except for the following source types:

• asyncapi that the AsyncAPI Service validates and, if required, converts to version 2.0 and the json format.
• markdown from which the Front Matter Service extracts front matter metadata.

TIP: The default Kyma webhooks that convert and validate asyncapi source files and extract metadata from markdown files are defined in the webhook-config-map.yaml ConfigMap.

The clustermicrofrontends.ui.kyma-project.io CustomResourceDefinition (CRD) is a detailed description of the kind of data and the format used to extend the Kyma Console. It allows you to extend the Console for the entire Cluster. The cluster micro frontend is added to Console automatically based on the yaml file. To avoid naming conflicts with the core system, the root node receives the cmf- prefix in the URL. Additionally, navigationContext and viewGroup node configuration parameters are set to allow simple navigation. To get the up-to-date CRD and show the output in the yaml format, run this command:

kubectl get crd clustermicrofrontends.ui.kyma-project.io -o yaml

Sample custom resource

This is a sample CR that extends the Console.

apiVersion: ui.kyma-project.io/v1alpha1
kind: ClusterMicroFrontend
metadata:
  name: sample-microfrontend
spec:
  version: 0.0.1
  category: category-name
  viewBaseUrl: https://sample-microfrontend-url.com
  placement: cluster
  navigationNodes:
    - label: Sample List
      navigationPath: items
      viewUrl: /
      requiredPermissions:
      - apiGroup: foo.bar.io
        resource: items
        verbs:
          - list
    - label: Details
      navigationPath: items/:id
      showInNavigation: false
      viewUrl: /:id
      requiredPermissions:
      - apiGroup: foo.bar.io
        resource: items
        verbs:
          - update
          - delete

This table lists all the possible parameters of a given resource together with their descriptions:

The backendmodules.ui.kyma-project.io CustomResourceDefinition (CRD) is a detailed description of the kind of data and the format used to enable Console Backend Service modules.

To get the up-to-date CRD and show the output in the yaml format, run this command:

kubectl get crd backendmodules.ui.kyma-project.io -o yaml

Sample custom resource

This is a sample CR that enables the servicecatalog module in the Console Backend Service:

apiVersion: ui.kyma-project.io/v1alpha1
kind: BackendModule
metadata:
  name: servicecatalog

Custom resource parameters

This table lists all the possible parameters of a given resource together with their descriptions:

Related resources and components

These components use this CR: