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

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 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.

This chapter describes how to set up a SUSE Private Registry. More details about the SUSE Private Registry can be found at https://documentation.suse.com/cloudnative/suse-private-registry/html/private-registry/pr-introduction.html

Note

The installation of SUSE Private Registry is not a mandatory requirement for the deployment of Edge Integration Cell and is thereby optional. To continue without using a SUSE Private Registry, refer to the next chapter Section 9, “Preparing storage”.

8.2 Deployment #

 

This chapter describes a basic example how to deploy the SUSE Private Registry without high-availability.

Warning

In the example deployment, self signed certificates will be used. It is highly recommended to use a trusted CA for signing certificates for production landscapes.

Before heading into the actual deployment, make sure to create a Kubernetes secret that holds your login information as described in: https://documentation.suse.com/en-us/cloudnative/suse-private-registry/html/private-registry/pr-deployment.html#pr-deployment-kube-secrets

8.2.1 Gathering login information #

 

Before you can deploy SUSE Private Registry, you’ll need to gather the login information for the official SUSE registry and store them as a Secret in your Kubernetes cluster.

NOTE

An always updated guide on this can be found at https://documentation.suse.com/en-us/cloudnative/suse-private-registry/html/private-registry/pr-deployment.html#pr-deployment-kube-secrets.

To fetch the login credentials, log in to the SUSE Customer Center and select the organization that holds the Registry subscription. Click Proxies as shown in the picture below:

Figure 9: SCC Proxy #

 

On the right hand side, you should see the Mirroring credentials with your user name and password, as shown below:

Figure 10: SCC Proxy Credentials #

 

You likely need to click the eye icon to reveal the password. For the rest of this guide, we’ll refer to these credentials as PRIVATE_REGISTRY_USERNAME and PRIVATE_REGISTRY_PASSWORD.

For the next few steps, we’re going to store the PRIVATE_REGISTRY_PASSWORD in a file password.txt. To log in and verify your credentials are working, run the command below:

head -1 ./password.txt | helm registry login registry.suse.com --username <PRIVATE_REGISTRY_USERNAME> --password-stdin

As a next step, create a namespace for the registry related resources.

kubectl create namespace <PRIVATE_REGISTRY_NAMESPACE>

The deployment will require an imagePullSecret that needs to be stored in the previously created namespace:

kubectl create secret docker-registry suse-registry \
  --namespace <PRIVATE_REGISTRY_NAMESPACE> \
  --docker-server=registry.suse.com \
  --docker-username=<PRIVATE_REGISTRY_USERNAME> \
  --docker-password=$(head -1 ./password.txt)

In our example the secret is called suse-registry and we’ll refer to it in the next chapter.

8.2.2 Deploying without high-availability #

 

The most basic approach to deploy is without high-availability, as there are no dependencies for a keystore and a database. The excerpt below shows example values that can be used with Helm to deploy the registry using a NodePort for exposure:

expose:
  type: nodePort
  nodePort:
    annotations: {}
    labels: {}
    name: harbor
    ports:
      http:
        nodePort: 30002
        port: 80
      https:
        nodePort: 30003
        port: 443
  tls:
    auto:
      commonName: <PRIVATE_REGISTRY_FQDN>
externalURL: https://<PRIVATE_REGISTRY_FQDN>
harborAdminPassword: "<MY_PASSWORD>"
imagePullPolicy: IfNotPresent
imagePullSecrets:
- name: suse-registry

Warning

The shown excerpt will create a self signed certificate for TLS. It is highly recommended to use a trusted CA for signing certificates for production landscapes.

To actually deploy, first create a file values.yaml and store the input of the excerpt above.

You can then run the command below to deploy SUSE Private Registry:

helm install suse-registry oci://registry.suse.com/private-registry/private-registry-helm -f values.yaml --namespace <PRIVATE_REGISTRY_NAMESPACE>

8.3 Preparing for SAP Edge Lifecycle Management #

 

8.3.1 Creating a registry user #

 

As a best practice we recommend to create a new user thats credentials are later shared with SAP Edge Lifecycle Management. If you already have an existing user or want to continue the deployment as admin, go the next chapter Section 8.3.2, “Creating a new project”.

To create new user, log in with an existing user that holds the permissions to create new users (for example, admin).

Figure 11: Create Registry User #

 

8.3.2 Creating a new project #

 

To use your registry for SAP Edge Lifecycle Management, you’ll need to create a project in which the images are getting stored. Therefore, log in to your registry and click NEW PROJECT as shown below:

Figure 12: Create Registry Project #

 

When created, access the project and download the registry certificate. This can be done using the download button REGISTRY CERTIFICATE in the project page:

Figure 13: Registry Certificate #

 

8.4 Using it with SAP Edge Lifecycle Management #

 

To use SUSE Private Registry with SAP Edge Lifecycle Management, you’ll need to configure the Rancher Kubernetes Engine 2 cluster that will be running the SAP Edge Lifecycle Management workload and adjust the configuration of your Edge Node.

8.4.1 Configuring the Rancher Kubernetes Engine 2 cluster that hosts ELM #

 

In order to avoid setting up multiple imagePullSecrets for each namespace, we recommend to add the SUSE Private Registry to you cluster configuration as described in Section 14.5, “Adding a registry”. If you are using self signed certificates or a certificate signed by an unknown CA, tick in the Skip TLS Verifications box.

8.4.2 Adjusting ELM Edge Node #

 

Opt in for "Replicate Container Images". As the Local Container Registry URL use the URL of your registry and append the project name to it. For example, if you registry is hosted at example.com and your project is called my-eic-project, then enter example.com/my-eic-project

Also make sure to toggle the Authentication to be enabled. Enter the user name and password for your registry.

When using a self signed certificate, opt-in the No-Trusted Certificate and upload the certificate, you fetched as described in Section 8.3, “Preparing for SAP Edge Lifecycle Management”.

Figure 14: ELM enable private registry #

 

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. We alternatively describe how you could use a SAP HANA in favor of PostgreSQL and/or Redis.

Note

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

10.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 15: Rancher Shell Access #

 

A shell will open as shown in the image below:

Figure 16: 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

10.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.

10.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.

10.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 14.1, “Creating an imagePullSecret for the Rancher Application Collection”.

To use self-signed certificates, find instructions on how to create them in Section 14.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 14.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 9, “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

10.5 Use SAP HANA #

 

Before getting started to prepare you SAP HANA for the usage with Edge Integration Cell, enusre the requirements described at https://me.sap.com/notes/3247839 are met.

This chapter describes a basic example of how to use SAP HANA with Edge Integration Cell. It will NOT instruct how to set up SAP HANA or high availability for SAP HANA.

Tip

For more information around high availability, refer to SUSE’s best practices guides

Tip

If you are looking for automated deployments of SAP HANA, there are Ansible scripts available at https://github.com/sap-linuxlab/ansible.playbooks_for_sap

10.5.1 Architecture overview #

 

Important

HANA is supposed to run in a side-by-side approach with the Edge Integration Cell Kubernetes cluster. SAP HANA is not part of that Kubernetes cluster. The picture below shows the side-by-side installation from an architectural point of view.

Figure 17: HANA architecture overview #

 

10.5.2 Prepare SAP HANA #

 

If you are planning to use a shared SAP HANA instance for Edge Integration Cell with other workloads, itis recommended to create a dedicated tenant database, user and schema for Edge Integration Cell.

To create a new tenant database log in to your installed SAP HANA. An example login command looks like:

 hdbsql -i 00 -d SYSTEMDB -u SYSTEM -p <password>

When logged in, run the following command to create a new tenant database:

CREATE DATABASE EICDB SYSTEM USER PASSWORD "SuperSecret123";

This will create a new tenant database EICDB and sets the database password to "SuperSecret123" After creation, you will need to login to the newly created database to create a new user and schema.

Similar to the previous log in, the our example uses now the newly created EICDB and the password from the command above:

hdbsql -i 00 -d EICDB -u SYSTEM -p "SuperSecret123"

After now being logged into the dedicated tenant database, you can now create the new user and the schema. In the following example we’ll create a user named EICUSER with the password YourPassword123 and the related schema EIC:

CREATE USER EICUSER PASSWORD "YourPassword123" NO FORCE_FIRST_PASSWORD_CHANGE;
GRANT DATA ADMIN TO EICUSER;
CREATE SCHEMA EIC;

Get the sql port for the newly created tenant database:

SELECT SQL_PORT FROM SYS.M_SERVICES WHERE SERVICE_NAME='indexserver';

10.5.3 Gather the HANA DB root cert #

 

The HANA DB root cert is required to deploy Edge Integration Cell with SAP HANA as the datastore or database. The certificate is stored locally on your HANA node and can be found in the $SECUDIR. Typically the name of the certificate is like:

clientpki_<SID>.cer

The file is located on the SAP HANA node and you can access is in the given directory. The hdbadm user usually has the SECUDIR variable set so you can easily change into that directory like:

cd $SECUDIR

10.5.4 Enter input #

 

When deploying Edge Integration Cell with HANA, you will be prompted to enter the relevant data.

The HANA DB Node requires the URL and port of your SAP HANA tenant database. You can get the port as described in the chapter above Section 10.5.2, “Prepare SAP HANA”.

The HANA DB Name is the name of the tenant database to use.
For the HANA DB Schema you can enter the name of the schema to be used.
The HANA DB Username is the name of the user, used to connect to SAP HANA.
The HANA DB Password is the password for the given user.

If you followed our example above, the values are:

HANA DB Node:       <hanaURL>:<portNumber>
HANA DB Name:       EICDB
HANA DB Schema:     EIC
HANA DB Username:   EICUSER
HANA DB Password:   YourPassword123

This section provides instructions for configuring Restricted Access option 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.

11.1 Configuring the Istio Service Mesh #

 

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

11.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 14.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 14.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 11.2.3, “Installing Kiali”, Prometheus at Section 11.2.1, “Installing Prometheus”, and Grafana at Section 11.2.2, “Installing Grafana”.

11.1.2 Deploying the chart #

 

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/.

11.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 11.1, “Configuring the Istio Service Mesh”.

11.2.1 Installing Prometheus #

 

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

11.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 11.1.1, “Installing Istio”. For instructions on how to create the imagePullSecret, refer to Section 14.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 14.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 9, “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

11.2.2 Installing Grafana #

 

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

11.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 11.1.1, “Installing Istio”. For instructions on how to create the imagePullSecret, refer to Section 14.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 14.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

11.2.3 Installing Kiali #

 

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

11.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 11.1.1, “Installing Istio” for deployment instructions.

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

• The Grafana application is already deployed. If not, refer to Section 11.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 11.1.1, “Installing Istio”. For instructions on how to create the imagePullSecret, refer to Section 14.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 14.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/.

11.3 Configuring Restricted Access for Kubernetes Clusters #

 

This section describes how to set up Restricted Access for Kubernetes Clusters, an operating model where SAP Edge Lifecycle Management and Edge Integration Cell are granted only the minimum necessary permissions required for their operation.

The configuration is divided into two stages to align with the deployment flow:

1. Phase 1: Access Provisioning for Edge Node Initialization: Applying initial security policies and setting up a restricted user in Rancher to initialize the Edge Node.

2. Phase 2: Access Provisioning for Edge Integration Cell Deployment: Applying solution-specific policies and granting permissions for Edge Integration Cell when the deployment is "Prepared".

To fulfill the infrastructure requirements, refer to the official SAP Note 3618713 (https://me.sap.com/notes/3618713).

Note

For Edge Integration Cell versions older than 8.41: You must manually apply the resources provided in the SAP Note mentioned above. Refer to Section 14.6, “Legacy Restricted Access Configuration (EIC < 8.41)” in the Appendix for the specific manual provisioning steps.

11.3.1 Phase 1: Access Provisioning for Edge Node Initialization #

 

When the Restricted Access to Kubernetes Cluster option is enabled during Edge Node creation, the SAP Edge Lifecycle Management UI will prompt you to download the required Kubernetes resources. Refer to the official SAP documentation for more details: https://help.sap.com/docs/edge-lifecycle-management/documentation/initializing-edge-node.

Extract the downloaded file and apply the resources to the Kubernetes cluster:

kubectl apply -f <extracted_directory>/

This action creates the edgelm namespace and applies the foundational security policies required by SAP Edge Lifecycle Management.

11.3.1.1 Configuring ImagePullSecrets for SAP Edge Lifecycle Management #

 

Since the edgelm namespace is targeted for Istio sidecar injection, it requires an imagePullSecret from the SUSE Application Collection. For detailed instructions, refer to Section 14.1, “Creating an imagePullSecret for the Rancher Application Collection”.

kubectl create secret docker-registry application-collection -n edgelm \
  --docker-server=dp.apps.rancher.io \
  --docker-username=<yourUser> \
  --docker-password=<yourPassword>

11.3.1.2 Creating the restricted user in Rancher #

 

You must create a dedicated restricted user in Rancher. SAP Edge Lifecycle Management uses this identity to securely connect to your cluster without requiring broad administrator privileges.

1. In Rancher, go to Users & Authentication > Create.

2. Set the user name (for example, eic-restricted) and select Standard User.

3. Record the User ID (formatted as "u-XXXXX") and password for the subsequent configuration steps.

4. Assign the user to the downstream cluster with Cluster Permission > Custom > View Nodes.

Figure 18: Rancher user id listed #

 

Figure 19: Rancher assign user membership #

 

11.3.1.3 Granting restricted user permissions for SAP Edge Lifecycle Management #

 

In this section, we associate the restricted user created in the previous section with the security policies. This binds the Rancher user to the exact rights required by SAP Edge Lifecycle Management, following the principle of least privilege.

Create a file named bind-elm-rbac.sh and add the following script:

#!/bin/bash
set -eu

if [ "$#" -ne 1 ]; then
  echo "Usage: $0 <USER_ID>"
  exit 1
fi
USER_ID="$1"
PAYLOAD=$(printf '[{"op":"add","path":"/subjects/-","value":{"apiGroup":"rbac.authorization.k8s.io","kind":"User","name":"%s"}}]' "$USER_ID")

echo "Binding ELM RoleBindings and ClusterRoleBindings for user: $USER_ID"

kubectl patch rolebindings rb-edgelm-manage -n edgelm --type=json -p "$PAYLOAD"
kubectl patch rolebindings rb-edgelm-admin -n edgelm --type=json -p "$PAYLOAD"
kubectl patch clusterrolebindings crb-edgelm-cluster-admin --type=json -p "$PAYLOAD"

echo "User permission binding for ELM complete."

Make the script executable and run it with your <USER_ID>:

chmod +x bind-elm-rbac.sh
./bind-elm-rbac.sh <USER_ID>

11.3.1.4 Download the kubeconfig #

 

This step generates a kubeconfig file that will be required by SAP Edge Lifecycle Management to perform the Edge Node initialization.

1. Log in to the Rancher UI using the credentials of the restricted user configured in Section 11.3.1.2, “Creating the restricted user in Rancher”.

2. Navigate to the target cluster.

3. Download the kubeconfig file.

Figure 20: Rancher download kubeconfig #

 

Continue with the steps referenced in the official SAP documentation: https://help.sap.com/docs/edge-lifecycle-management/documentation/initializing-edge-node.

11.3.2 Phase 2: Access Provisioning for Edge Integration Cell Deployment #

 

When the Edge Node is "Available", initiate the Edge Integration Cell solution deployment in the SAP Edge Lifecycle Management UI. When the solution reaches the Prepared state, return here to apply the specific solution resources.

Download the second zip (for example, restricted-resources-Edge_Integration_Cell-<version>.zip) from the SAP Edge Lifecycle Management UI and extract it to a directory (for example, eic-resources). Apply it to the cluster:

kubectl apply -f eic-resources/

This action creates the necessary namespaces for Edge Integration Cell and applies the required security policies for the solution components.

11.3.2.1 Configuring ImagePullSecrets for EIC namespaces #

 

The previous step generated the solution-specific namespaces (istio-gateways, edge-icell, edge-icell-services, edge-icell-secrets, and edge-icell-ela).

With the exception of edge-icell-secrets, all of these namespaces require an imagePullSecret to authenticate against the registry. For detailed background instructions, refer to Section 14.1, “Creating an imagePullSecret for the Rancher Application Collection”.

You can automate the creation of these secrets by creating a file named create-eic-ips.sh with the following content:

#!/bin/bash

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

Remember to replace <yourUser> and <yourPassword> with your actual registry credentials inside the script before executing it:

chmod +x create-eic-ips.sh
./create-eic-ips.sh

11.3.2.2 Granting restricted user permissions for Edge Integration Cell #

 

Just as in Phase 1, Section 11.3.1.3, “Granting restricted user permissions for SAP Edge Lifecycle Management”, you must bind the restricted Rancher user to the newly generated solution-specific policies.

Create a file named bind-eic-rbac.sh and add the following script:

#!/bin/bash
set -eu

if [ "$#" -ne 1 ]; then
  echo "Usage: $0 <USER_ID>"
  exit 1
fi
USER_ID="$1"

echo "Adding EIC RoleBindings for user: $USER_ID"

PAYLOAD=$(printf '[{"op":"add","path":"/subjects/-","value":{"apiGroup":"rbac.authorization.k8s.io","kind":"User","name":"%s"}}]' "$USER_ID")

for RB in \
  "istio-gateways:rb-edgelm-manage" \
  "istio-gateways:rb-istio-gateways-admin" \
  "edge-icell-services:rb-edgelm-manage" \
  "edge-icell-services:rb-admin" \
  "edge-icell-services:rb-app-admin" \
  "edge-icell:rb-edgelm-manage" \
  "edge-icell:rb-admin" \
  "edge-icell:rb-app-admin" \
  "edge-icell-secrets:rb-edgelm-manage" \
  "edge-icell-secrets:rb-admin" \
  "edge-icell-ela:rb-edgelm-manage" \
  "edge-icell-ela:rb-admin" \
  "edge-icell-ela:rb-app-admin"
do
  NAMESPACE="${RB%%:*}"
  NAME="${RB##*:}"
  echo "Binding $NAME in namespace $NAMESPACE..."
  kubectl patch rolebindings "$NAME" -n "$NAMESPACE" --type=json -p "$PAYLOAD"
done

echo "User permission binding for EIC complete."

Make it executable and run it with your USER_ID:

chmod +x bind-eic-rbac.sh
./bind-eic-rbac.sh <USER_ID>

When the permissions are successfully bound, return to the SAP Edge Lifecycle Management UI and click Resume deployment.

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.

Note

For Restricted Access: Since you have already initiated, paused, and resumed the deployment wizard in the SAP Edge Lifecycle Management UI to apply the specific manifests (as described in the previous section), the core deployment step is already complete. You should continue following the official SAP guide to verify the installation and perform any necessary post-deployment configurations.

Copyright © 2006-2026 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.