ScaleIT-Komponenten und wie man damit arbeitet

ScaleIT App-Registry

Die ScaleIT App-Registry beinhaltet alle gestarteten Apps (unabhängig davon, ob sie genutzt werden).

Für die ScaleIT App-Regsitry wird ETCD genutzt (ein Key-Value Store aus CoreOS).

Jede App muss sich

• beim Start (in Rancher) in die App-Registry eintragen und
• beim Beenden aus der App-Regsitry wieder entfernen

Für diese Funktion einer App kann das Registration Sidecar genutzt werden. Es erleichtert die Registrierung und Deregistrierung in der ScaleIT App-Registry sehr. Es wird in einer App als Container eingebunden, die Werte in docker-compose konfiguriert und fertig.

Einbau des Registrierungs-Sidecar in die eigene App

Unter PlatformSidecars wird das Registration Sidecar eingebaut:

   $ git clone https://github.com/scaleit-i40/registration.git
   $ cd registration
   $ rm -rf ./git
   $ git add .
   $ git commit -m "registration sidecar eingebaut" .

Damit ist das Registration Sidecar ein Teil der App.

Es kann unabhängig von der späteren ScaleIT Betriebsumgebung getestet werden.

Im Verzeichnis des Registration Sidecars müssen hierzu die Services im Test gestartet werden:

   $ pwd
   .../PlatformSidecars/registration
   $ make build
   $ make up
   $ make logs

Es werden folgende Services gestartet:

• ETCD: Simulierte App-Registry zum Test
• ETCD-Browser: Damit kann der Inhalt der App-Registry angezeigt werden
• Registration Sidecar

Das Registration Sidecar trägt beim Start alle App-Daten in die App Regsitry ein und löscht diese beim Beenden wieder.

Die Tests werden so wieder beendet:

   $ make down

Registrierungs-Parameter

Der Teil der Datei docker-compose.yml zur Registrierung für eine App de-ondics-pacman sollte aussehen wie im Readme des Sidecars beschrieben:

   services:
       ...
       # Registration sidecar
       de-ondics-pacman-registration:
           image: registry.app-pool.scaleit-i40.de/nilsclauss/ondics-dev/de-ondics-pacman-registration:1.1
           restart: always
           environment:
             - APP_ID=de-ondics-pacman
             - APP_NAME=ScaleIT Pacman
             - APP_TITLE=ScaleIT Pacman
             - APP_SHORT_DESCRIPTION=ScaleIT Pacman
             - APP_DESCRIPTION=ScaleIT Pacman Web-Game
             - APP_CATEGORY=domainApp
             - APP_DOMAIN_PORT=${APP_DOMAIN_PORT}
             - APP_DOMAIN_PATH=/
             - APP_DOMAIN_DESCRIPTION=ScaleIT Pacman
             - APP_ICON_PORT=${APP_SIDECAR_WEBCONTENT_PORT}
             - APP_ICON_PATH=/icon.png
             - HOST_IP=${HOST_IPADDR}
             - SSO_ACTIVATED=${ssoproxy}
             - SSO_APP_PREFIX=${DOMAINPREFIX}
             - APP_WEBCONTENT_SERVICENAME=webcontent
             - APP_API_SERVICE=webcontent
             - APP_API_PORT=${APP_DOMAIN_PORT}
             - APP_API_PATH=/api/
             - STACK_NAME=Vorlage:.Stack.Name

Die Einträge sind fast selbsterklärend. Hier ein paar Bemerkungen dazu:

• Die Endpunkte der App werden jeweils mit _PORT und _PATH und _SERVICE angegeben. Zusammen mit den Variablen SSO_ACTIVATED und SSO_APP_PREFIX wird daraus eine korrekte URL erstellt (entweder mit Namens- oder Portadressierung)
• mehrere Urls können auf den gleichen Endpunkt zeigen
• Die Port-Nummern sind mit dem Ökosystem-Betreiber abzustimmen
• Die Variable ${ssoproxy} (gesteuert durch Rancher) entscheidet, welche Art der Adressierung verwendet wird.

Als App-Kategorien sind vorgesehen:

• Core (ScaleIT-System-App, wird im Launchpad nicht angezeigt)
• Digitaler Zwilling (App mit Bezug zu Maschinen oder Sensoren)
• Workflow (Verarbeitende App)
• domainApp

Nutzung von ETCD in einer eigenen App

Der ETCD Key-Value-Speicher kann auch für App-eigene Zwecke verwendet werden. Hierzu gilt:

• Wenn eine App eigene Daten in ETCD hinterlegen will, muss sie einen Top-Knoten dafür erstellen. Der Name muss der Name der App und der Rancher-Stackname sein:

   de-xyz-myapp.de-xyz-myapp_app_1
   

Grund: Fall eine App mehrfach gestartet wird (mehrere Instanzen), bekommt jede ihren eigenen Key-Value-Speicher.

• Die App muss diesen eigenen Knoten auch wieder entfernen, wenn sie "degraded" oder gelöscht wird

Eine Referenzimplementierung eines Registration Sidecars steht unter https://github.com/scaleit-i40/registration

Debugging von ETCD-Einträgen

In der ETCD-App ist ein Web-Service integriert, mit dem im Browser die ETCD-Einträge angesehen werden können.

Hierzu muss zunächst der Web-Service im Browser gestartet werden:

   http://<host-ip>:49502

Dann muss im Web-Formular der ETCD-Service eingetragen werden:

   http://<host-ip>:49501

Anschließend können die ETCD-Nodes angesehen werden (per Klick auf einen Node kann dieser geöffnet werden).

ACHTUNG: Änderungen eines Nodes werden beim nächsten App-Start überschrieben.

ScaleIT App-Messaging

ScaleIT Messaging ist der Kommunikation von Apps untereinander.

ScaleIT Messaging ist ein Publish-Subscribe Mechanismus, der auf MQTT basiert:

• Apps versenden Nachrichten (als "Publisher") mit bestimmten Überschriften ("Topics")
• Apps können Message über Topics abonnieren (als "Subscriber")

Herzstück dabei ist der MQTT Broker, der die Nachrichten von den Publisher entgegennimmt und an die Subscriber weiterleitet.

Als MQTT Broker kommt im ScaleIT Core Mosquitto zum Einsatz.

Die verwendeten Ports sind:

• MQTT: Port 1883
• MQTT über Websockets: 1884

Der MQTT-Broker kann von jeder App aus erreicht werden über

• den Hostname bzw. die IP-Adresse, die beim App-Start mitgegeben wird
• den internene Domainnamen der MQTT-App, der von Rancher vergeben wird: [service_name].[stack_name]:1883, z.B. "de-ondics-scaleit-core-ce-mqtt.de-ondics-scaleit-core-ce"

Beide Adressierungen funktionieren in der ScaleIT Core Community und Enterprise Edition.

Die interne Kommunikation mit dem MQTT-Broker erfolgt ohne Verschlüsselung und ohne Benutzeranmeldung.

Eine ScaleIT App, die Nachrichten versenden will, muss dieses gemäß der ScaleIT Message Spezifikation tun. Damit ist sichergestellt, dass Nachrichten von möglichst vielen Apps untereinander ausgetauscht und die Nachrichten beliebig erweitert werden können.

Jeder App-Hersteller ist für die Dokumentation der Nachrichten verantwortlich, die eine App versendet.

Zur ScaleIT Messaging Spezifikation

ScaleIT Sidecar Webcontent

Das Sicecar "Webcontent" wurde entwickelt, um statische Inhalt in einer App per Web-Server zur Verfügung zu stellen.

Das Sidecar wird im docker-compose wie folgt eingebaut:

    de-ondics-nodered-webcontent:
        image: registry.app-pool...../de-ondics-nodered-webcontent:1.0
        {{- if eq .Values.ssoproxy "false"}}
        ports:
          - "${APP_SIDECAR_WEBCONTENT_PORT}:80"
        {{- else}}
        labels:
          rap.host: webcontent-${DOMAINPREFIX}
        {{- end}}

Die rap.host Angabe muss mit einem "-" getrennt werden, da zusätzliche Subdomains von SSL-Wildcard-Zertifikaten nicht akzeptiert werden.