SAP Edge Integration Cell on SUSE #

This guide describes how to prepare your infrastructure for the installation of Edge Integration Cell on Rancher Kubernetes Engine 2 using SUSE Rancher Prime. It will guide you through the steps of:

Note

This guide does not contain information about sizing your landscapes. Visit https://help.sap.com/docs/integration-suite?locale=en-US and search for the "Edge Integration Cell Sizing Guide".

The support matrix below shows which versions of the given software we will use in this guide.

Important

If you want to use different versions of SUSE Linux Enterprise Micro or SUSE Linux Micro, SUSE Rancher Prime, Rancher Kubernetes Engine 2, or SUSE Storage, make sure to check the support matrix for the related solutions you want to use: https://www.suse.com/suse-rancher/support-matrix/all-supported-versions/
For Redis and PostgreSQL, make sure to pick versions compatible to Edge Integration Cell, which can be found at https://me.sap.com/notes/3247839 .

Other versions of MetalLB or cert-manager can be used, but they may not have been tested.

* The Rancher for SAP applications subscription holds support for all required components like SUSE Linux Enterprise Micro, SUSE Rancher Prime and SUSE Storage.

** Only needed if you want to set up SUSE Rancher Prime in a high availability setup

Additionally,

To run Edge Integration Cell in a production-ready and supported way, you need to set up multiple Kubernetes clusters and their nodes. Those comprise a Kubernetes cluster, where you will install SUSE Rancher Prime to set up and manage the production and non-production clusters. For this SUSE Rancher Prime cluster, we recommend using three Kubernetes nodes and a load balancer.

The Edge Integration Cell will need to run in a dedicated Kubernetes cluster. For an HA setup of this cluster, we recommend using three Kubernetes control planes and three Kubernetes worker nodes.

For a graphical overview of what is needed, take a look at the landscape overview:

Figure 1: Architecture Overview #

 

This graphic overview is used throughout the guide to illustrate the purpose and context of each step.

Starting with installing the operating system of each machine or Kubernetes node, we will guide you through the complete setup of a Kubernetes landscape ready for Edge Integration Cell deployment.

There are several ways to install SUSE Linux Enterprise Micro 6.0. For this best practice guide, we use the installation method via graphical installer. But in cloud native deployments, it is highly recommended to use Infrastructure-as-Code technologies to fully automate the deployment and lifecycle processes.

5.1 Installing and configuring SUSE Linux Enterprise Micro #

 

On each server in your environment for Edge Integration Cell and SUSE Rancher Prime, install SUSE Linux Enterprise Micro 6.0 as the operating system. There are several methods to install SUSE Linux Enterprise Micro 6.0 on your hardware or virtual machine. A list of all possible solutions are available in our Documentation SLE Micro 6.0.

At the end of the installation process, in the summary window, you need to verify that the following security settings are configured:

• The firewall will be disabled.

• The SSH service will be enabled.

• SELinux will be set in permissive mode.

Set SELinux to permissive mode, because otherwise, some components of the Edge Integration Cell will violate SELinux rules, and the application will not work.

Tip

If you have already set up all machines and the operating system, skip this chapter.

sudo transactional-update register -r REGISTRATION_CODE -e EMAIL_ADDRESS

sudo  transactional-update register -r REGISTRATION_CODE -e EMAIL_ADDRESS \
--url "https://suse_register.example.com/"

sudo transactional-update

sudo systemctl --now disable transactional-update.timer

sudo transactional-update pkg install lvm2 jq nfs-client cryptsetup open-iscsi

sudo reboot

sudo systemctl enable iscsid  --now

sudo pvcreate /dev/vdb

sudo vgcreate vgdata /dev/vdb

sudo lvcreate -n lvlonghorn -l100%FREE vgdata

sudo mkfs.xfs /dev/vgdata/lvlonghorn

sudo mkdir -p /var/lib/longhorn

sudo echo -e "/dev/vgdata/lvlonghorn /var/lib/longhorn xfs defaults 0 0" >> /etc/fstab

sudo mount -a

By now, you should have the operating system installed on every Kubernetes node. You are ready to install a SUSE Rancher Prime cluster. Referring to the landscape overview, we now focus on how to set up the upper section of the graphic below:

Figure 2: Architecture SUSE Rancher Prime #

 

sudo zypper in haproxy

sudo cat <<EOF > /etc/haproxy/haproxy.cfg
global
        log /dev/log    local0
        log /dev/log    local1 notice
        chroot /var/lib/haproxy
        # stats socket /run/haproxy/admin.sock mode 660 level admin
        stats timeout 30s
        user haproxy
        group haproxy
        daemon

        # general hardlimit for the process of connections to handle, this is separate to backend/listen
        # Added in 'global' AND 'defaults'!!! - global affects only system limits (ulimit/maxsock) and defaults affects only listen/backend-limits - hez
        maxconn 400000

        # Default SSL material locations
        ca-base /etc/ssl/certs
        crt-base /etc/ssl/private

        tune.ssl.default-dh-param 2048

        # Default ciphers to use on SSL-enabled listening sockets.
        # For more information, see ciphers(1SSL). This list is from:
        #  https://hynek.me/articles/hardening-your-web-servers-ssl-ciphers/
        ssl-default-bind-ciphers ECDH+AESGCM:DH+AESGCM:ECDH+AES256:DH+AES256:ECDH+AES128:DH+AES:ECDH+3DES:DH+3DES:RSA+AESGCM:RSA+AES:RSA+3DES:!aNULL:!MD5:!DSS
        ssl-default-bind-options ssl-min-ver TLSv1.2 no-tls-tickets

defaults
        mode tcp
        log     global
        option  tcplog
        option  redispatch
        option  tcpka
        option  dontlognull
        retries 2
        timeout connect 5s
        timeout client  5s
        timeout server  5s
        timeout tunnel  86400s
        maxconn 400000

listen stats
        bind *:9000
        mode http
        stats hide-version
        stats uri /stats

listen rancher_apiserver
        bind my_lb_address:6443
        option httpchk GET /healthz
        http-check expect status 401
        server mynode1 mynode1.domain.local:6443 check check-ssl verify none
        server mynode2 mynode2.domain.local:6443 check check-ssl verify none
        server mynode3 mynode3.domain.local:6443 check check-ssl verify none
listen rancher_register
        bind my_lb_address:9345
        option httpchk GET /ping
        http-check expect status 200
        server mynode1 mynode1.domain.local:9345 check check-ssl verify none
        server mynode2 mynode2.domain.local:9345 check check-ssl verify none
        server mynode3 mynode3.domain.local:9345 check check-ssl verify none

listen rancher_ingress80
        bind my_lb_address:80
        option httpchk GET /
        http-check expect status 404
        server mynode1 mynode1.domain.local:80 check
        server mynode2 mynode2.domain.local:80 check
        server mynode3 mynode3.domain.local:80 check

listen rancher_ingress443
        bind my_lb_address:443
        option httpchk GET /
        http-check expect status 404
        server mynode1 mynode1.domain.local:443 check check-ssl verify none
        server mynode2 mynode2.domain.local:443 check check-ssl verify none
        server mynode3 mynode3.domain.local:443 check check-ssl verify none
EOF

haproxy -f /path/to/your/haproxy.conf -c

sudo systemctl enable haproxy
sudo systemctl start haproxy

6.2 Installing RKE2 #

 

To install RKE2, the script provided at https://get.rke2.io can be used as follows:

sudo curl -sfL https://get.rke2.io | INSTALL_RKE2_VERSION=v1.31.7+rke2r1 sh

For HA setups, you must create RKE2 cluster configuration files in advance. On the first master node, do the following:

sudo mkdir -p /etc/rancher/rke2
cat <<EOF > /etc/rancher/rke2/config.yaml
token: 'your cluster token'
system-default-registry: registry.rancher.com
tls-san:
  - FQDN of fixed registration address on load balancer
  - other hostname
  - IP v4 address
EOF

Create configuration files for additional cluster nodes:

cat <<EOF > /etc/rancher/rke2/config.yaml
server: https://"FQDN of registration address":9345
token: 'your cluster token'
system-default-registry: registry.rancher.com
tls-san:
  - FQDN of fixed registration address on load balancer
  - other hostname
  - IP v4 address
EOF

Important

You also need to consider taking etcd snapshots and perform backups of your Rancher instance. These topics are not covered in this document, but you can find more information in our official documentation. Helpful links are https://documentation.suse.com/cloudnative/rke2/latest/en/backup_restore.html and https://documentation.suse.com/cloudnative/rancher-manager/latest/en/rancher-admin/back-up-restore-and-disaster-recovery/back-up-restore-and-disaster-recovery.html. IMPORTANT: For security reasons, we generally recommend activating the CIS profile when installing RKE2. This is currently still being validated and will be included in the documentation at a later date.

Now enable and start the RKE2 components and run the following command on each cluster node:

sudo systemctl enable rke2-server --now

To verify the installation, run the following command:

/var/lib/rancher/rke2/bin/kubectl --kubeconfig /etc/rancher/rke2/rke2.yaml get nodes

For convenience, you can add the kubectl binary to the $PATH and set the specified kubeconfig via an environment variable:

export PATH=$PATH:/var/lib/rancher/rke2/bin/
export KUBECONFIG=/etc/rancher/rke2/rke2.yaml

curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

kubectl create namespace cert-manager

helm install cert-manager oci://dp.apps.rancher.io/charts/cert-manager \
    --set crds.enabled=true \
    --set-json 'global.imagePullSecrets=[{"name":"application-collection"}]' \
    --namespace=cert-manager \
    --version 1.15.2

helm repo add rancher-prime https://charts.rancher.com/server-charts/prime

kubectl create namespace cattle-system

helm install rancher rancher-prime/rancher \
    --namespace cattle-system \
    --set hostname=<your.domain.com> \
    --set replicas=3

kubectl -n cattle-system rollout status deploy/rancher

After having installed the SUSE Rancher Prime cluster, you can use it to create Rancher Kubernetes Engine 2 clusters for Edge Integration Cell. SAP recommends setting separate QA/Dev systems for Edge Integration Cell in addition to a production landscape. Both can be configured similarly using SUSE Rancher Prime, as described in this chapter. Referring to the landscape overview, we now focus on the lower section of the graphic below:

Figure 3: Architecture Overview RKE2 #

 

Creating new RKE2 clusters is straightforward when using SUSE Rancher Prime.

Navigate to the home menu of your SUSE Rancher Prime instance and click the Create button on the right side of the screen, as shown below:

Figure 4: Rancher home menu #

 

The window displays the available options for creating new Kubernetes clusters. Make sure the toggle button on the right side of the screen is set to RKE2/K3s, as shown below:

Figure 5: Rancher RKE version selection #

 

If you want to create Kubernetes clusters on existing (virtual) machines, select the Custom option at the very bottom, as shown in the image below:

Figure 6: Rancher create custom cluster #

 

Next, a window will appear where you can configure your Kubernetes cluster. It will look similar to the image below:

Figure 7: Rancher create custom cluster config #

 

Here, you need to name the cluster. The name will only be used within SUSE Rancher Prime. It will not affect your workloads. In the next step, make sure you select a Kubernetes version that is supported by the workload you want to deploy.

If you do not have any further requirements to Kubernetes, you can click the Create button at the very bottom. In any other cases, talk to your administrators before making adjustments.

After you clicked Create, you should see a screen similar to the below:

Figure 8: Rancher create registration #

 

Now, in a first step, select the roles your node(s) should receive. A common high availability setup holds:

The next step is to copy the registration command to the target machines' shell and execute it. If your SUSE Rancher Prime instance holds a self-signed certificate, make sure to activate the text bar holding the registration command in the check box below.

You can run the command on all nodes in parallel. You do not need to wait until a single node is down. When all machines are registered, you can see the cluster status at the top, changing from "updating" to "active". At this point in time, your Kubernetes cluster is ready to be used.

To make storage available for Kubernetes workloads, prepare the storage solution you want to use. In this chapter, we describe how to set this up and how to prepare it for consumption by Edge Integration Cell.

The storage solutions tested by SAP and SUSE are presented below, along with links to chapters detailing how to set them up and configure them.

curl -sSfL https://raw.githubusercontent.com/longhorn/longhorn/v1.6.2/scripts/environment_check.sh | bash

helm repo add rancher-v2.8-charts https://raw.githubusercontent.com/rancher/charts/release-v2.8
helm repo update
helm upgrade --install longhorn-crd rancher-v2.8-charts/longhorn-crd \
--namespace longhorn-system \
--create-namespace
helm upgrade --install longhorn rancher-v2.8-charts/longhorn \
--namespace longhorn-system

sudo zypper in -y lsscsi multipath-tools open-iscsi

sudo zypper remove -y kernel-default-base
sudo zypper in -y kernel-default

sudo systemctl enable --now iscsi
sudo systemctl enable --now multipathd

helm repo add netapp-trident https://netapp.github.io/trident-helm-chart
helm install my-trident-operator netapp-trident/trident-operator --version 100.2502.1 --create-namespace --namespace trident

apiVersion: v1
kind: Secret
metadata:
  name: backend-tbc-ontap-secret
  namespace: trident
type: Opaque
stringData:
  username: <cluster-admin>
  password: <password>

apiVersion: trident.netapp.io/v1
kind: TridentBackendConfig
metadata:
  name: backend-tbc-ontap-san
  namespace: trident
spec:
  version: 1
  backendName: ontap-san-backend
  storageDriverName: ontap-san
  managementLIF: <Cluster IP>
  dataLIF: <Storage-VM-IP>
  svm: <Storage-VM-FQDN>
  credentials:
    name: backend-tbc-ontap-secret

apiVersion: trident.netapp.io/v1
kind: TridentBackendConfig
metadata:
  name: backend-tbc-ontap-nas
  namespace: trident
spec:
  version: 1
  backendName: ontap-nas-backend
  storageDriverName: ontap-nas
  managementLIF: <Cluster-IP>
  dataLIF: <Storage-VM-IP>
  svm: <Storage-VM-FQDN>
  credentials:
    name: backend-tbc-ontap-secret

kubectl -n trident get tbc backend-tbc-ontap-san

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: nfs
provisioner: csi.trident.netapp.io
parameters:
  backendType: ontap-san

In the following chapter, we present an example for setting up MetalLB, Redis and PostgreSQL.

Note

Keep in mind that the descriptions and instructions below might differ from the deployment you need for your specific infrastructure and use cases.

9.1 Logging in to Rancher Application Collection #

 

To access the Rancher Application Collection, you need to log in. You can do this using the console and Helm client. The easiest way to do so is to use the built-in shell in SUSE Rancher Prime. To access it, navigate to your cluster and click Kubectl Shell as shown below:

Figure 9: Rancher Shell Access #

 

A shell will open as shown in the image below:

Figure 10: Rancher Shell Overview #

 

You must log in to Rancher Application Collection. This can be done as follows:

helm registry login dp.apps.rancher.io/charts -u <yourUser> -p <your-token>

kubectl create namespace metallb

global:
  imagePullSecrets:
    - name: application-collection

helm install metallb oci://dp.apps.rancher.io/charts/metallb \
-f values.yaml \
--namespace=metallb \
--version 0.14.7

cat <<EOF >iprange.yaml
apiVersion: metallb.io/v1beta1
kind: IPAddressPool
metadata:
  name: first-example-pool
  namespace: metallb
spec:
  addresses:
  - 192.168.1.240/32
EOF

cat <<EOF > l2advertisement.yaml
apiVersion: metallb.io/v1beta1
kind: L2Advertisement
metadata:
  name: example
  namespace: metallb
EOF

kubectl apply -f iprange.yaml
kubectl apply -f l2advertisement.yaml

9.3 Installing Redis #

 

Before deploying Redis, ensure that the requirements described at https://me.sap.com/notes/3247839 are met.

Also, make sure you understand what grade of persistence you want to achieve for your Redis cluster. For more information about persistence in Redis, see https://redis.io/docs/management/persistence/.

IMPORTANT

SUSE does not offer database support for Redis. For support requests, contact Redis Ltd..

IMPORTANT

The following instructions describe only one variant of installing Redis which is called Redis Cluster. There are other possible ways to set up Redis that are not covered in this guide. Check if you require Redis Sentinel instead of Redis Cluster.

9.3.1 Deploying Redis #

 

Although Redis is available for deployment using the SUSE Rancher Prime Apps, we recommend using the Rancher Application Collection. The Redis chart can be found at https://apps.rancher.io/applications/redis.

9.3.1.1 Deploying the chart #

 

To deploy the chart, create the related namespace and imagePullSecret first. To create the namespace, run:

kubectl create namespace redis

Instructions how to create the imagePullSecret can be found in Section 13.1, “Creating an imagePullSecret for the Rancher Application Collection”.

If you want to use self-signed certificates, you can find instructions how to create such in Section 13.3.1, “Creating self-signed certificates”.

Before you can install the application, you need to log in to the registry. You can find the instructions in Section 13.2, “Logging in to the Application Collection Registry”.

Create a file values.yaml to store some configurations for the Redis Helm chart. The configuration might look like the following:

images:
  redis:
    # -- Image registry to use for the Redis container
    registry: dp.apps.rancher.io
    # -- Image repository to use for the Redis container
    repository: containers/redis
    # -- Image tag to use for the Redis container
    tag: 7.2.5
storageClassName: "longhorn"
global:
  imagePullSecrets: ["application-collection"]
architecture: cluster
nodeCount: 3
auth:
  password: <redisPW>
tls:
  # -- Enable TLS
  enabled: true
  # -- Whether to require Redis clients to authenticate with a valid certificate (authenticated against the trusted root CA certificate)
  authClients: false
  # -- Name of the secret containing the Redis certificates
  existingSecret: "redisCert"
  # -- Certificate filename in the secret
  certFilename: "server.pem"
  # -- Certificate key filename in the secret
  keyFilename: "server.key"
  #  CA certificate filename in the secret - needs to hold the CA.crt and the server.pem
  caCertFilename: "root.pem"

Note

The storageClassName in the values.yaml file should be adjusted to match the storage class you intend to use. For more details on configuring storage, refer to Section 8, “Preparing storage”.

To install the application, run:

helm install redis oci://dp.apps.rancher.io/charts/redis \
-f values.yaml \
--namespace=redis \
--version 0.2.2

kubectl create namespace postgresql

global:
  # -- Global override for container image registry pull secrets
  imagePullSecrets: ["application-collection"]
images:
  postgresql:
    # -- Image registry to use for the PostgreSQL container
    registry: dp.apps.rancher.io
    # -- Image repository to use for the PostgreSQL container
    repository: containers/postgresql
    # -- Image tag to use for the PostgreSQL container
    tag: "15.7"
auth:
  # -- PostgreSQL username for the superuser
  postgresUsername: postgres
  # -- PostgreSQL password for the superuser
  postgresPassword: "<your_password>"
  # -- Replication username
  replicationUsername: replication
  # -- Replication password
  replicationPassword: "<your_password>"
tls:
  # -- Enable SSL/TLS
  enabled: false
  # -- Name of the secret containing the PostgreSQL certificates
  existingSecret: "postgresqlcert"
  # -- Whether or with what priority a secure SSL TCP/IP connection will be negotiated with the server. Valid values: prefer (default), disable, allow, require, verify-ca, verify-full
  sslMode: "verify-full"
  # -- Certificate filename in the secret (will be ignored if empty)
  certFilename: "server.pem"
  # -- Certificate key filename in the secret (will be ignored if empty)
  keyFilename: "server.key"
  # -- CA certificate filename in the secret (will be ignored if empty)
  caCertFilename: "root.pem"
statefulset:
  # -- Enable the StatefulSet template for PostgreSQL standalone mode
  enabled: true
  # -- Lifecycle of the persistent volume claims created from PostgreSQL volumeClaimTemplates
  persistentVolumeClaimRetentionPolicy:
    ## -- Volume behavior when the StatefulSet is deleted
    whenDeleted: Delete
podSecurityContext:
  # -- Enable pod security context
  enabled: true
  # -- Group ID for the pod
  fsGroup: 1000

helm install postgresql oci://dp.apps.rancher.io/charts/postgresql -f values.yaml --namespace=postgresql --version 0.1.0

This section provides instructions for configuring Restricted Access feature for Edge Integration Cell.

Note

Keep in mind that the descriptions and instructions provided might differ from the deployment requirements for your specific infrastructure and use cases.

10.1 Configuring the Istio Service Mesh #

 

This section guides you through configuring the Istio Service Mesh for the Restricted Access feature on Edge Integration Cell.

10.1.1 Installing Istio #

 

Even though Istio is available for deployment using the SUSE Rancher Prime Apps, we recommend to use the Rancher Application Collection. The Istio chart can be found at https://apps.rancher.io/applications/istio.

Before deploying Istio, ensure that the requirements described at https://me.sap.com/notes/3247839 are met.

To deploy the chart, create the related namespace and imagePullSecret first.

To create the namespace, run:

kubectl create namespace istio-system

Instructions how to create the imagePullSecret can be found in Section 13.1, “Creating an imagePullSecret for the Rancher Application Collection”.

Before you can install the application, you need to log in to the registry. You can find the instructions in Section 13.2, “Logging in to the Application Collection Registry”.

Note

The istio-system namespace, imagePullSecret, and registry login established for Istio will be reused by: Kiali at Section 10.2.3, “Installing Kiali”, Prometheus at Section 10.2.1, “Installing Prometheus”, and Grafana at Section 10.2.2, “Installing Grafana”.

10.1.1.1 Deploying Istio #

 

Create a file values.yaml to store some configurations for the Istio Helm chart. The configuration might look like the following:

global:
  imagePullSecrets:
    - name: application-collection

To install the application, run:

helm install istiod oci://dp.apps.rancher.io/charts/istio \
-f values.yaml \
--namespace=istio-system \
--version 1.0.2

For more information on installing and configuring Istio, check the reference guide at https://docs.apps.rancher.io/reference-guides/istio/.

10.2 Configuring monitoring #

 

This section covers the deployment of key monitoring and observability tools that integrate with the Istio Service Mesh configured previously in Section 10.1, “Configuring the Istio Service Mesh”.

10.2.1 Installing Prometheus #

 

The Prometheus chart can be found at https://apps.rancher.io/applications/prometheus.

10.2.1.1 Deploying the chart #

 

Before deploying Prometheus, ensure that the requirements described at https://me.sap.com/notes/3247839 are met.

Deploy Prometheus into the istio-system namespace, which should already be configured with an imagePullSecret, as this is a prerequisite for Istio at Section 10.1.1, “Installing Istio”. For instructions on how to create the imagePullSecret, refer to Section 13.1, “Creating an imagePullSecret for the Rancher Application Collection”.

Before you can install the application, you need to log in to the registry. Find the instructions in Section 13.2, “Logging in to the Application Collection Registry”.

Create a file values.yaml to store some configurations for the Prometheus Helm chart. The configuration might look like the following:

alertmanager:
  persistentVolume:
    storageClassName: longhorn
global:
  imagePullSecrets:
    - application-collection
server:
  persistentVolume:
    storageClassName: longhorn

Note

The storageClassName in the values.yaml file should be adjusted to match the storage class you intend to use. For more details on configuring storage, refer to Section 8, “Preparing storage”.

To install the application, run:

helm install prometheus oci://dp.apps.rancher.io/charts/prometheus \
-f values.yaml \
--namespace=istio-system \
--version 27.37.0

10.2.2 Installing Grafana #

 

The Grafana chart can be found at https://apps.rancher.io/applications/grafana.

10.2.2.1 Deploying the chart #

 

Before deploying Grafana, ensure that the requirements described at https://me.sap.com/notes/3247839 are met.

Deploy Grafana into the istio-system namespace, which should already be configured with an imagePullSecret, as this is a prerequisite for Istio at Section 10.1.1, “Installing Istio”. For instructions on how to create the imagePullSecret, refer to Section 13.1, “Creating an imagePullSecret for the Rancher Application Collection”.

Also, before you install the application, ensure you are logged in to the registry; you will find those instructions in Section 13.2, “Logging in to the Application Collection Registry”.

Create a file values.yaml to store some configurations for the Grafana Helm chart. The configuration might look like the following:

datasources:
  datasources.yaml:
    apiVersion: 1
    datasources:
    - name: Prometheus
      type: prometheus
      url: http://prometheus-server.istio-system
      access: proxy
      isDefault: true
global:
  imagePullSecrets:
    - application-collection
# Optional: Expose Grafana with a LoadBalancer
# service:
#   enabled: true
#   type: LoadBalancer

To install the application, run:

helm install grafana oci://dp.apps.rancher.io/charts/grafana \
-f values.yaml \
--namespace=istio-system \
--version 9.4.4

10.2.3 Installing Kiali #

 

The Kiali chart can be found at https://apps.rancher.io/applications/kiali.

10.2.3.1 Deploying the chart #

 

Before deploying Kiali, ensure the following prerequisites are met:

• The Istio application is already deployed. If not, refer to Section 10.1.1, “Installing Istio” for deployment instructions.

• The Prometheus application is already deployed. If not, refer to Section 10.2.1, “Installing Prometheus” for deployment instructions.

• The Grafana application is already deployed. If not, refer to Section 10.2.2, “Installing Grafana” for deployment instructions.

Deploy Prometheus into the istio-system namespace, which should already be configured with an imagePullSecret, as this is a prerequisite for Istio at Section 10.1.1, “Installing Istio”. For instructions on how to create the imagePullSecret, refer to Section 13.1, “Creating an imagePullSecret for the Rancher Application Collection”.

Before you can install the application, you need to log in to the registry. You can find the instructions in Section 13.2, “Logging in to the Application Collection Registry”.

Create a values.yaml file to store some configurations for the Kiali Helm chart. You can do this by running the following command:

GRAFANA_PASSWORD=$(kubectl get secret --namespace istio-system grafana -o jsonpath="{.data.admin-password}" | base64 -d ; echo)
cat <<EOF > values.yaml
external_services:
  grafana:
    auth:
      type: basic
      username: admin
      password: $GRAFANA_PASSWORD
    enabled: true
    external_url: http://grafana.istio-system
    internal_url: http://grafana.istio-system
  prometheus:
    custom_metrics_url: http://prometheus-server.istio-system
    url: http://prometheus-server.istio-system
global:
  imagePullSecrets:
    - application-collection
# Optional: Expose the Kiali with an Ingress
# deployment:
#   ingress:
#     enabled: true
EOF

To install the application, run:

helm install kiali oci://dp.apps.rancher.io/charts/kiali \
-f values.yaml \
--namespace=istio-system \
--version 2.15.0

Note

For more information on installing and configuring Kiali, check the reference guide at https://docs.apps.rancher.io/reference-guides/kiali/.

10.3 Configuring the cluster for restricted access #

 

To install SAP Edge Lifecycle Management and deploy Edge Integration Cell with Restricted Access, you need to configure specific namespaces, Kubernetes Custom Resource Definitions (CRDs), and Role-Based Access Control (RBAC). Refer to https://me.sap.com/notes/3618713 for detailed instructions on creating and configuring these components.

Note

The RBAC configured here will be utilized in the subsequent section to grant permissions to the restricted user, as detailed in Section 10.4.3, “Configuring restricted access user permissions”.

After creating the required namespaces, verify they are correctly created and labeled for Istio injection by navigating to Cluster > Project/Namespaces.

Figure 11: Rancher namespaces #

 

The following namespaces are targeted for Istio sidecar injection and must have an imagePullSecret to enable image pulling:

• edgelm

• edge-icell

• edge-icell-services

• edge-icell-ela

• istio-gateways

For instructions on creating the imagePullSecret, refer to Section 13.1, “Creating an imagePullSecret for the Rancher Application Collection”.

Alternatively, run the following script to create the imagePullSecret in all required namespaces:

NAMESPACES_INJECTION=("edgelm" "edge-icell" "edge-icell-services" "edge-icell-ela" "istio-gateways")
for ns in "${NAMESPACES_INJECTION[@]}"; do
  echo "Creating imagePullSecret for namespace: $ns"
  kubectl create secret docker-registry application-collection -n $ns \
    --docker-server=dp.apps.rancher.io \
    --docker-username=<yourUser> \
    --docker-password=<yourPassword>
  sleep 1
  echo "---"
done
echo "Done"

10.4 Generating the kubeconfig file #

 

The Edge Integration Cell Restricted Access deployment requires a kubeconfig file, which you can download from the Rancher UI.

In this section, we create a restricted user and grant the necessary permissions for Edge Integration Cell deployment. The process involves assigning the restricted user to the downstream cluster and subsequently using their account to download the kubeconfig file from Rancher.

10.4.1 Creating the restricted user #

 

1. Navigate to "Users & Authentication" and click Create.

2. Set a username (e.g., eic-restricted), a password, and select Global Permissions > Standard User.

3. Record this password for subsequent configuration steps.

After creation, the new user will be listed. Record the User ID (formatted as "u-XXXXX"), as both the ID and password are required for assigning permissions in the downstream cluster.

Note

This restricted user only needs to be created once in Rancher, as user management is centralized and applies to all downstream clusters.

Figure 12: Rancher users list #

 

10.4.2 Assigning restricted user to the cluster #

 

Assign the newly created restricted user to the downstream cluster where Edge Integration Cell will be deployed.

1. Navigate to Cluster > Cluster and Project Members in the Rancher UI.

2. Click Add. Select the restricted user and choose Cluster Permission > Custom > View Nodes.

Figure 13: Rancher add user membership #

 

10.4.3 Configuring restricted access user permissions #

 

The restricted user needs specific permissions to deploy Edge Integration Cell. These permissions are granted through ClusterRoleBindings and RoleBindings, which were created during the namespace configuration process described in Section 10.3, “Configuring the cluster for restricted access”.

Create a script file named configuring_permissions.sh with the following content. Remember to replace USER_ID with the actual ID of the restricted user you created earlier:

#!/bin/bash
set -eu

if [ "$#" -ne 1 ]; then
  echo "Usage: $0 <USER_ID>"
  exit 1
fi
# Restricted user ID to be added
USER_ID="$1"

echo "Adding EIC ClusterRoleBindings and RoleBindings for user: $USER_ID"

# crb-edgelm-cluster-admin
kubectl patch clusterrolebindings crb-edgelm-cluster-admin --type=json \
-p='[{"op": "add", "path": "/subjects/-", "value": {"apiGroup": "rbac.authorization.k8s.io", "kind": "User", "name": "'$USER_ID'"}}]'

# rb-edgelm-manage for every namespace
kubectl patch rolebindings rb-edgelm-manage -n edgelm --type=json \
-p='[{"op": "add", "path": "/subjects/-", "value": {"apiGroup": "rbac.authorization.k8s.io", "kind": "User", "name": "'$USER_ID'"}}]'
kubectl patch rolebindings rb-edgelm-manage -n istio-gateways --type=json \
-p='[{"op": "add", "path": "/subjects/-", "value": {"apiGroup": "rbac.authorization.k8s.io", "kind": "User", "name": "'$USER_ID'"}}]'
kubectl patch rolebindings rb-edgelm-manage -n edge-icell --type=json \
-p='[{"op": "add", "path": "/subjects/-", "value": {"apiGroup": "rbac.authorization.k8s.io", "kind": "User", "name": "'$USER_ID'"}}]'
kubectl patch rolebindings rb-edgelm-manage -n edge-icell-secrets --type=json \
-p='[{"op": "add", "path": "/subjects/-", "value": {"apiGroup": "rbac.authorization.k8s.io", "kind": "User", "name": "'$USER_ID'"}}]'
kubectl patch rolebindings rb-edgelm-manage -n edge-icell-ela --type=json \
-p='[{"op": "add", "path": "/subjects/-", "value": {"apiGroup": "rbac.authorization.k8s.io", "kind": "User", "name": "'$USER_ID'"}}]'
kubectl patch rolebindings rb-edgelm-manage -n edge-icell-services --type=json \
-p='[{"op": "add", "path": "/subjects/-", "value": {"apiGroup": "rbac.authorization.k8s.io", "kind": "User", "name": "'$USER_ID'"}}]'

# rb-edgelm-admin
kubectl patch rolebindings rb-edgelm-admin -n edgelm --type=json \
-p='[{"op": "add", "path": "/subjects/-", "value": {"apiGroup": "rbac.authorization.k8s.io", "kind": "User", "name": "'$USER_ID'"}}]'
kubectl patch rolebindings rb-istio-gateways-admin -n istio-gateways --type=json \
-p='[{"op": "add", "path": "/subjects/-", "value": {"apiGroup": "rbac.authorization.k8s.io", "kind": "User", "name": "'$USER_ID'"}}]'

# rolebindings for edge-icell namespace
kubectl patch rolebindings rb-app-admin -n edge-icell --type=json \
-p='[{"op": "add", "path": "/subjects/-", "value": {"apiGroup": "rbac.authorization.k8s.io", "kind": "User", "name": "'$USER_ID'"}}]'
kubectl patch rolebindings rb-admin -n edge-icell --type=json \
-p='[{"op": "add", "path": "/subjects/-", "value": {"apiGroup": "rbac.authorization.k8s.io", "kind": "User", "name": "'$USER_ID'"}}]'

# rolebindings for edge-icell-ela namespace
kubectl patch rolebindings rb-app-admin -n edge-icell-ela --type=json \
-p='[{"op": "add", "path": "/subjects/-", "value": {"apiGroup": "rbac.authorization.k8s.io", "kind": "User", "name": "'$USER_ID'"}}]'
kubectl patch rolebindings rb-admin -n edge-icell-ela --type=json \
-p='[{"op": "add", "path": "/subjects/-", "value": {"apiGroup": "rbac.authorization.k8s.io", "kind": "User", "name": "'$USER_ID'"}}]'

# rolebinding for edge-icell-secrets namespace
kubectl patch rolebindings rb-admin -n edge-icell-secrets --type=json \
-p='[{"op": "add", "path": "/subjects/-", "value": {"apiGroup": "rbac.authorization.k8s.io", "kind": "User", "name": "'$USER_ID'"}}]'

# rolebindings for edge-icell-services namespace
kubectl patch rolebindings rb-app-admin -n edge-icell-services --type=json \
-p='[{"op": "add", "path": "/subjects/-", "value": {"apiGroup": "rbac.authorization.k8s.io", "kind": "User", "name": "'$USER_ID'"}}]'
kubectl patch rolebindings rb-admin -n edge-icell-services --type=json \
-p='[{"op": "add", "path": "/subjects/-", "value": {"apiGroup": "rbac.authorization.k8s.io", "kind": "User", "name": "'$USER_ID'"}}]'

echo "Done"

Run the script with the USER_ID obtained from the previous step:

chmod +x configuring_permissions.sh
./configuring_permissions.sh <USER_ID>

10.4.4 Download the restricted access kubeconfig file #

 

Once the restricted user is created and configured for the downstream cluster, download the kubeconfig file.

1. Log in to the Rancher UI with the restricted user’s credentials.

2. Navigate to the target cluster for Edge Integration Cell deployment.

3. Download the kubeconfig file.

Figure 14: Rancher download kubeconfig #

 

At this point, you should be able to deploy Edge Integration Cell. Follow the instructions at https://help.sap.com/docs/integration-suite/sap-integration-suite/setting-up-and-managing-edge-integration-cell to install Edge Integration Cell in your prepared environments.

Copyright © 2006–2025 SUSE LLC and contributors. All rights reserved.

Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or (at your option) version 1.3; with the Invariant Section being this copyright notice and license. A copy of the license version 1.2 is included in the section entitled "GNU Free Documentation License".

SUSE, the SUSE logo and YaST are registered trademarks of SUSE LLC in the United States and other countries. For SUSE trademarks, see https://www.suse.com/company/legal/.

Linux is a registered trademark of Linus Torvalds. All other names or trademarks mentioned in this document may be trademarks or registered trademarks of their respective owners.

Documents published as part of the SUSE Best Practices series have been contributed voluntarily by SUSE employees and third parties. They are meant to serve as examples of how particular actions can be performed. They have been compiled with utmost attention to detail. However, this does not guarantee complete accuracy. SUSE cannot verify that actions described in these documents do what is claimed or whether actions described have unintended consequences. SUSE LLC, its affiliates, the authors, and the translators may not be held liable for possible errors or the consequences thereof.

Below we draw your attention to the license under which the articles are published.

Copyright © 2000, 2001, 2002 Free Software Foundation, Inc. 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.

The purpose of this License is to make a manual, textbook, or other functional and useful document "free" in the sense of freedom: to assure everyone the effective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modifications made by others.

This License is a kind of "copyleft", which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free software.

We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or reference.

This License applies to any manual or other work, in any medium, that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. Such a notice grants a world-wide, royalty-free license, unlimited in duration, to use that work under the conditions stated herein. The "Document", below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as "you". You accept the license if you copy, modify or distribute the work in a way requiring permission under copyright law.

A "Modified Version" of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language.

A "Secondary Section" is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document’s overall subject (or to related matters) and contains nothing that could fall directly within that overall subject. (Thus, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them.

The "Invariant Sections" are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License. If a section does not fit the above definition of Secondary then it is not allowed to be designated as Invariant. The Document may contain zero Invariant Sections. If the Document does not identify any Invariant Sections then there are none.

The "Cover Texts" are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License. A Front-Cover Text may be at most 5 words, and a Back-Cover Text may be at most 25 words.

A "Transparent" copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, that is suitable for revising the document straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent file format whose markup, or absence of markup, has been arranged to thwart or discourage subsequent modification by readers is not Transparent. An image format is not Transparent if used for any substantial amount of text. A copy that is not "Transparent" is called "Opaque".

Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML, PostScript or PDF designed for human modification. Examples of transparent image formats include PNG, XCF and JPG. Opaque formats include proprietary formats that can be read and edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML, PostScript or PDF produced by some word processors for output purposes only.

The "Title Page" means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title page as such, "Title Page" means the text near the most prominent appearance of the work’s title, preceding the beginning of the body of the text.

A section "Entitled XYZ" means a named subunit of the Document whose title either is precisely XYZ or contains XYZ in parentheses following text that translates XYZ in another language. (Here XYZ stands for a specific section name mentioned below, such as "Acknowledgements", "Dedications", "Endorsements", or "History".) To "Preserve the Title" of such a section when you modify the Document means that it remains a section "Entitled XYZ" according to this definition.

The Document may include Warranty Disclaimers next to the notice which states that this License applies to the Document. These Warranty Disclaimers are considered to be included by reference in this License, but only as regards disclaiming warranties: any other implication that these Warranty Disclaimers may have is void and has no effect on the meaning of this License.

You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3.

You may also lend copies, under the same conditions stated above, and you may publicly display copies.

If you publish printed copies (or copies in media that commonly have printed covers) of the Document, numbering more than 100, and the Document’s license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects.

If the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages.

If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a computer-network location from which the general network-using public has access to download using public-standard network protocols a complete Transparent copy of the Document, free of added material. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public.

It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document.

You may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this License, with the Modified Version filling the role of the Document, thus licensing distribution and modification of the Modified Version to whoever possesses a copy of it. In addition, you must do these things in the Modified Version:

If the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in the Modified Version’s license notice. These titles must be distinct from any other section titles.

You may add a section Entitled "Endorsements", provided it contains nothing but endorsements of your Modified Version by various parties—​for example, statements of peer review or that the text has been approved by an organization as the authoritative definition of a standard.

You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one.

The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modified Version.

You may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice, and that you preserve all their Warranty Disclaimers.

The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but different contents, make the title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work.

In the combination, you must combine any sections Entitled "History" in the various original documents, forming one section Entitled "History"; likewise combine any sections Entitled "Acknowledgements", and any sections Entitled "Dedications". You must delete all sections Entitled "Endorsements".

You may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects.

You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document.

A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, is called an "aggregate" if the copyright resulting from the compilation is not used to limit the legal rights of the compilation’s users beyond what the individual works permit. When the Document is included in an aggregate, this License does not apply to the other works in the aggregate which are not themselves derivative works of the Document.

If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one half of the entire aggregate, the Document’s Cover Texts may be placed on covers that bracket the Document within the aggregate, or the electronic equivalent of covers if the Document is in electronic form. Otherwise they must appear on printed covers that bracket the whole aggregate.

Translation is considered a kind of modification, so you may distribute translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of this License, and all the license notices in the Document, and any Warranty Disclaimers, provided that you also include the original English version of this License and the original versions of those notices and disclaimers. In case of a disagreement between the translation and the original version of this License or a notice or disclaimer, the original version will prevail.

If a section in the Document is Entitled "Acknowledgements", "Dedications", or "History", the requirement (section 4) to Preserve its Title (section 1) will typically require changing the actual title.

You may not copy, modify, sublicense, or distribute the Document except as expressly provided for under this License. Any other attempt to copy, modify, sublicense or distribute the Document is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.

The Free Software Foundation may publish new, revised versions of the GNU Free Documentation License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. See http://www.gnu.org/copyleft/.

Each version of the License is given a distinguishing version number. If the Document specifies that a particular numbered version of this License "or any later version" applies to it, you have the option of following the terms and conditions either of that specified version or of any later version that has been published (not as a draft) by the Free Software Foundation. If the Document does not specify a version number of this License, you may choose any version ever published (not as a draft) by the Free Software Foundation.

Copyright (c) YEAR YOUR NAME.
   Permission is granted to copy, distribute and/or modify this document
   under the terms of the GNU Free Documentation License, Version 1.2
   or any later version published by the Free Software Foundation;
   with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
   A copy of the license is included in the section entitled “GNU
   Free Documentation License”.

If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, replace the “ with…​Texts.” line with this:

with the Invariant Sections being LIST THEIR TITLES, with the
   Front-Cover Texts being LIST, and with the Back-Cover Texts being LIST.

If you have Invariant Sections without Cover Texts, or some other combination of the three, merge those two alternatives to suit the situation.

If your document contains nontrivial examples of program code, we recommend releasing these examples in parallel under your choice of free software license, such as the GNU General Public License, to permit their use in free software.