5  Zuhörthemen

5.1 Freie und offene Software

Opensource Logo, siehe https://opensource.org

  • Warum Linux, bzw. allgemein Open-Source Software verwenden?

    • Ich habe die volle Kontrolle und es liegt in meiner Macht, Stichwort “Selbstermächtigung”.

    • Ich habe eine weltweite Gemeinde im Rücken, die viel stärker ist und viel schneller reagiert als eine Firma/ein Konzern.

    • Ich kann selber mitmachen, da ich alle Werkzeuge auf meinem Standard Linux habe.

    • Alle anderen können weltweit auch an meinen Projekten mitmachen, da sie auch alle Werkzeuge haben. Zur Erinnerung: Viele Menschen haben keinen Zugang zur kommerziellen Softwarewelt.

    • Vollkommene Freiheit, da keine erzwungenen Abhängigkeiten. Der von Kunden gefürchtete “vendor lock-in” wird von Herstellern nur zu gern verordnet.

    • Wenn es um Sicherheit geht, sind geschlossene kommerzielle Programme sofort aus dem Spiel. Mit anderen Worten, maximale Sicherheit kann nur durch offengelegte Software hergestellt werden.

    • Linux läuft gut auf alten Rechnern, erzeugt weniger Müll (im Gegensatz dazu siehe die aktuelle Entwicklung bei Windows 11). Siehe auch “5 Reasons” bei https://endof10.org.

  • Wichtige Ereignisse

  • Immer auf die Lizenz schauen!

        liberal  <-------------------------------------------> streng
                  MIT                           GPLv2
                  BSD                           GPLv3
                  Apache 2.0                    LGPL
                                                AGPL
                                             (Copyleft)

    Viele weitere, siehe https://opensource.org/licenses

  • Was manche als Nachteile von freier Software empfinden:

    • Es gibt alles im Überfluß, z.B. hunderte Linux Distributionen die alle anders aussehen und teilweise auch anders funktionieren. Das verwirrt viele. Gegensatz: Windows sieht immer gleich aus, das beruhigt.

    • Alles kann in sehr unterschiedlichen Qualitätsstufen existieren, von extrem gut bis zu totalem Schrott. Ich muss mir selber ein Bild machen und mich informieren.

  • Alles was wir im Kurs verwenden ist offen

  • Lesen und Schauen

Aufgabenideen

  1. Finden sie heraus, unter welchen Lizenzen (kommerziell oder freie/open-source) die Programme stehen, die sie im Alltag (zu Hause und im Beruf) verwenden. Machen Sie eine Tabelle mit den Spalten Plattform, Programm, Zweck, Lizenz. Die Plattform ist dabei entweder PC Mac/Windows/Linux oder Smartphone App. Finden sie heraus, ob es freie Alternativen zu den kommerziellen Programmen gibt, die sie verwenden und schreiben sie diese in eine fünfte Spalte.

  2. Versuchen Sie doch mal auf das freie Linux Betriebssystem umzusteigen, zumindest versuchsweise. Sie müssen dazu auch nicht ihr Windows kaputt machen. Lassen Sie das für Umsteiger einfachste Linux – Linux Mint – einfach in einer virtuellen Maschine (z.B. in VirtualBox https://www.virtualbox.org) laufen. Nehmen Sie Linux Mint in der Cinnamon Edition, das ist am nächsten am typischen Windows Desktop dran https://linuxmint.com.

5.2 UART

Teletype aus den 40er Jahren

Das Bild habe ich dem Artikel von Linus Akesson entnommen (https://www.linusakesson.net/programming/tty/). Es zeigt Fernschreiber (teletypes) aus den 1940er Jahren. Der UART und das TTY Subsystem von UNIX geht auf diese Technologie zurück.

  • Asynchrone serielle Schnittstelle, entwickelt Anfang der 60er Jahre von Fa. DEC (Gordon Bell, [1]). Die Abkürzung bedeutet Universal Asynchronous Receiver Transmitter. Oft auch einfach “serielle Schnittstelle” genannt.

  • Asynchron bedeutet, daß kein Taktsignal übertragen wird.

  • Übertragen werden heute meist nur noch die zwei Signale TX (transmit) und RX (receive) zwischen zwei Geräten. Es gibt noch einige Kontroll- und “Handshake”-Signale, die aus der Zeit der Terminal- und Modem-Verbindungen stammen, z.B. RTS, CTS, RTR, DSR, DTR, die heute aber fast keine Bedeutung mehr haben.

                  +--------+                 +--------+
              |      TX|---------------->|RX      |
              | A      |                 |      B |
              |      RX|<----------------|TX      |
              +--------+                 +--------+
                   |                         |
                  GND                       GND

    Das Signal auf TX und RX wechselt zwischen 0V und 5V oder 0V und 3.3V.

  • Häufig verwendete Geschwindigkeiten sind 9600, 19200 und 115200 Bit/s (früher “Baud” genannt). Die maximale Datenrate liegt bei ein paar MBit/s.

    Neben den Datenbits wird auch ein Startbit und ein Stopbit übertragen. Das Paritybit ist optional (folgendes Bild ist von [2] entnommen).

    UART Signale

    Wichtig ist, dass Teilnehmer A und B jeweils auf die gleichen Parameter eingestellt werden:

    • Geschwindigkeit in Bit/s
    • Anzahl Datenbits (5, 6, 7, 8)
    • Paritybit (O=odd, E=even, N=non)
    • Länge des Stopbit (1, 2)

    Häufig verwendete Werte sind: 9600-8-N-1, 115200-8-N-1.

  • Früher hatten PCs meist eine RS-232 Schnittstelle, prinzipiell ein UART, der aber mit den Spannungswerten +12V und -12V arbeitet ([3]).

    RS-232 Schnittstelle am PC

    Wer heute am PC eine serielle Schnittstelle benötigt, verwendet meist einen USB-zu-UART Adapter, z.B. mit den gängigen ICs CP2102, FT232 oder CH340.

    USB-zu-UART Adapter mit CP2102 Chip

    Oft ist dieser oder ein ähnlicher Baustein auf dem Mikrocontrollerboard bereits aufgelötet, so dass man das Board nur noch an den USB Bus des PC anstecken muss. In Abbildung 3.1 sieht man z.B. einen CP2102 Baustein.

  • Unter Linux ist jeder angesteckte USB-UART einem Gerät zugeordnet, z.B. /dev/ttyUSB0 oder /dev/ttyACM0. Am besten man lässt sich alle Geräte mit ls /dev/tty* ausgeben. Unter Windows ist das die “COM” Schnittstelle.

    Um von Linux aus Daten über den UART zu senden und zu empfangen benötigt man einen “Terminal Emulator”. Das sind meistens Kommandozeilenprogramme (CLI : Command Line Interpreter) z.B.

    Die Programme müssen über Kommandozeilenoptionen auf die Parameter der Gegenstelle eingestellt werden. Meist wird nur die Geschwindigkeit eingestellt, da der Rest fast immer mit 8-N-1 voreingestellt ist. Beispiel:

    $ picocom -b 115200 /dev/ttyUSB3

    Tipps:

    • Aus picocom kommt man wieder heraus mit Strg-A Strg-X (bei gedrückter Strg-Taste nacheinander A und X drücken).

    • Bei einem frisch installierten Linux hat man als gewöhnlicher User keinen Zugriff auf die Gerätedatei. Folgendes Kommando ermöglicht auch dem normalen User einen Zugang:

      $ sudo usermod -aG dialout $USER

      Danach den Rechner neu starten, damit das Kommando wirksam wird.

  • Auch das weiter unten vorgestellte mpremote Programm kommuniziert über die serielle Schnittstelle mit dem Mikrocontroller.

  • Man kann auf die serielle Schnittstelle auch per Programm zugreifen. Am einfachsten geht das mit Python und dem pyserial Paket. Alles Nötige ist in der Beschreibung unter https://pythonhosted.org/pyserial zu finden. Sie können damit ein Programm schreiben, das auf allen Betriebssystemen (Linux, Mac, Windows) funktioniert!

  • Mehr zum UART

    https://de.wikipedia.org/wiki/Universal_Asynchronous_Receiver_Transmitter

Aufgabenideen

  1. Stecken Sie einen USB-zu-UART Adapter an ihren PC und verbinden Sie TX mit RX. Versuchen Sie mit einem Terminal-Emulator Daten zu schreiben und wieder zu empfangen.

  2. Nehmen Sie nun zwei USB-zu-UART Adapter, einen für ihren PC, den anderen für den des Nachbarn. Kommunizieren Sie zwischen beiden PCs über die UART Verbindung. Verwenden Sie einen Terminal-Emulator ihrer Wahl.

  3. Versuchen Sie nun die ersten beiden Versuche statt mit dem Terminal-Emulator mit einem Python Programm und dem pyserial Modul zu erledigen.

5.3 Arduino

https://www.arduino.cc

Arduino Logo

Arduino ist ein enorm erfolgreiches Projekt, das die Programmierung von Mikrocontrollern stark vereinfacht hat. Vor allem Hobbyisten und Maker, aber auch teilweise kommerzielle Firmen verwenden das im Jahr 2005 entstandene Framework. Viele Jahre konzentrierte sich Arduino auf den Atmel AVR 8-Bit Prozessor [5], später wurden dann auch andere Prozessoren wie ARM, ESP8266 und ESP32 unterstützt.

Die Programmierung erfolgt im Prinzip mit C++, es wird jedoch ein Präprozessor verwendet, der manche Sachen vereinfacht. Dateien mit Quelltext heissen nun Sketch, folgendes Programm zeigt die prinzipielle Struktur:

// https://docs.arduino.cc/language-reference/en/structure/sketch/loop

int buttonPin = 3;

// setup initializes serial and the button pin
void setup() {
  Serial.begin(9600);
  pinMode(buttonPin, INPUT);
}

// loop checks the button pin each time,
// and will send serial if it is pressed
void loop() {
  if (digitalRead(buttonPin) == HIGH) {
    Serial.write('H');
  }
  else {
    Serial.write('L');
  }
  delay(1000);
}

Es gibt vor allem keine main() Funktion mehr, dafür gibt es nun setup() und loop().

Weitere interessante Merkmale sind

  • Häufig verwendete Programmkomponenten wie die serielle Schnittstelle oder diverse Bussysteme, z.B. I2C und SPI sind in Klassen verpackt, Stichwort objektorientierte Programmierung.

  • Es gibt Bibliotheken für eine riesige Menge an Hardware-Bauelementen, auch hier werden die Bauelemente oft objektorientiert modelliert.

  • Die Arduino IDE stellt alles Nötige unter einer einfachen Bedienoberfläche zur Verfügung. Auch hier steht nicht der Profi im Vordergrund, sondern die einfache Bedienbarkeit für den Anfänger, Hobbyisten und Maker.

    Arduino IDE

    Hinweis: Als Alternative zur Arduino IDE kann man auch mit Platformio und dem Arduino Framework arbeiten. Hier erfolgt die Arbeit nicht-grafisch, sondern auf der Kommandozeile. Somit eignet sich dieser Weg besser für die Automatisierung.
    Die Firmware für das Projekt 1 werden wir mit Hilfe von Platformio und dem Arduino Framework bauen.

Literatur

5.4 Platformio

Platformio Logo

  • https://platformio.org

  • Von Ivan Kravets (Ukraine), ab ca. 2016, https://www.ikravets.com/about-me

  • Freies Meta-Framework zur Embedded Programmierung

    “PlatformIO is a cross-platform code builder and the missing library manager”

  • What is PlatformIO? https://docs.platformio.org/en/latest/what-is-platformio.html

  • Einheitliche Entwicklung bei riesigem Angebot an Plattformen, Frameworks, Boards, Bibliotheken.

    Kleiner Auszug:

    Plattform     Framework        Board         Bibliothek

8051          arduino          1.300+        13.000+                         
avr           espidf
esp32         cmsis
esp8266       stmcube
stm32         zephyr
riscv         mbed
...           ...

  • Die Firmware auf dem Heltec V3 Board des LoRaWAN Projekts ist mit dem Arduino Framework gemacht. Kompiliert wird es nicht in der Arduino IDE, sondern mit Platformio auf der Kommandozeile.

5.5 CSV

CSV Icon

Beispiel

Pos,  Anzahl, Best-Nr,  Beschreibung,   Einzelpreis
1, 4,   4801391,  Heltec LoRa V3,   23.95   
2, 10,  512489, "Widerstand, 470 Ohm", 0.10
3, 1,  193726, Digitast Taster,    3,86     <-- Fehler!

Zu beachten:

  • Welche Zeichenkodierung? (ASCII, UTF-8, ISO-8859-1, …)
  • Welcher Feld-Trenner wird verwendet? Im Beispiel ist es das Komma.
  • Welches Zeilenende? (Linux: 0x0a, Windows: 0x0d, 0x0a)
  • Was ist, wenn im Feld das Trennzeichen vorkommt? (field quoting)
  • Was ist, wenn nicht alle Zeilen die gleiche Anzahl Felder haben? Fehlertoleranz ist hier gefragt.
  • Haben all Daten in einer Spalte den gleichen Typ? Erst mal hat man nur Zeichenketten (Strings). Die Lesesoftware macht daraus aber oft konkrete Typen. In der CSV Datei oben wäre das int, int, int, string, float. Was ist wenn ein Typ aus der Reihe fällt?
  • Sind in der ersten Zeile die Spaltennamen?
  • Was passiert mit Leerzeilen?

Obwohl das Format einfach erscheint, sollte man den Code zum Schreiben/Lesen von CSV Dateien nicht selber schreiben sondern bewährte Bibliotheken verwenden.

In Python verwendet man am besten das CSV Modul. Wer mit komplexeren Tabellendaten arbeiten muss der ist mit der Pandas Bibliothek gut beraten. Pandas nennt tabellarische Daten Dataframes. Pandas hat bereits Lese- und Schreibroutinen für CSV, Excel und viele andere Formate eingebaut. Ich empfehle das freie Buch vom Pandas Autor Wes McKinney Python for Data Analysis (3E), https://wesmckinney.com/book. Tipp: Mit Pandas kann man auch meist auf die Daten von Zeitserien Datenbanken zugreifen (wie bei der QuestDB, siehe weiter unten).

Es gibt einige schöne CLI Tools für CSV:

5.6 JSON

https://json.org

JSON Icon

  • Datentypen: int, float (4.7, 1.0E+2), string (" ... "), bool, object ({ ... }), array ([ ... ]), null.

  • Keine Kommentare erlaubt!

  • Demo (prüfen/formatieren mit jq < _demo.json oder python -mjson.tool _demo.json)

    {
"Veranstaltung": "IOT Kurs",
"Ort": "Dillingen",
"Max": 12,
"Personen": [
  "Hans",
  "Paula",
  "Michael",
  "Claudia"
],
"Ausstattung": {
  "Werkzeug": [
    "Schraubenzieher",
    "Lötkolben"
  ],
  "Bauteile": [
    "Microcontroller",
    "Steckbrett"
  ]
},
"A-Bool": true,
"A-Float": 1.0
}

  • https://wiki.selfhtml.org/wiki/JSON

  • https://www.w3schools.com/js/js_json_intro.asp

  • JQ ist ein CLI Programm zum Verarbeiten von JSON Objekten. Verarbeiten bedeutet filtern, zerteilen, transformieren, suchen, so wie das die Programme sed, awk, grep für normalen Text machen.

    Beispiel: Das folgende JSON Objekt sieht unübersichtlich aus.

    {"StatusSNS":{"Time":"2022-01-03T14:52:33","ENERGY":{"TotalStartTime":
"2022-01-03T13:17:28","Total":0.017,"Yesterday":0.000,"Today":0.017,
"Power":17,"ApparentPower":31,"ReactivePower":26,"Factor":0.53,
"Voltage":238,"Current":0.130}}}

    Mit jq formatiert sieht es so aus (das Objekt ist in Datei obj.json):

    $ cat obj.json | jq .
{
  "StatusSNS": {
    "Time": "2022-01-03T14:52:33",
    "ENERGY": {
      "TotalStartTime": "2022-01-03T13:17:28",
      "Total": 0.017,
      "Yesterday": 0.000,
      "Today": 0.017,
      "Power": 17,
      "ApparentPower": 31,
      "ReactivePower": 26,
      "Factor": 0.53,
      "Voltage": 238,
      "Current": 0.130
    }
  }
}

    Den Spannungswert hole ich z.B. mit folgendem Kommando heraus:

    $ cat obj.json | jq .StatusSNS.ENERGY.Voltage
238

    Man kann die Datei wieder “komprimieren” mit

    jq -c . obj.json

  • json-linter CLI tool in Python

    https://pypi.org/project/json-linter

5.7 HTTP

URLs – siehe Details in http/skorkin-about-urls.txt

<scheme>://<username>:<password>@<host>:<port>/<path>?<query>#<fragment>

http://www.blah.com/some/crazy/path.html?param1=foo&param2=bar
http://www.blah.com/some/crazy/path.html?param1=foo&param2=bar#page2

Reservierte Zeichen in URLs:

";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" | "$" | ","

Escape mit %<ASCII-HEX-CODE>, siehe man ascii:

␣ → %20 (Leerzeichen)
% → %25
& → %26

HTTP ist ein ASCII Protokoll

Browser an Webserver:

GET /wiki/Startseite HTTP/1.1
Host: wiki.selfhtml.org
User-Agent: Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:55.0) Gecko/20100101 Firefox/55.0
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate, br

Webserver an Browser:

HTTP/1.1 200 OK
Date: Mon, 28 Aug 2017 09:02:55 GMT
Content-language: de-formal
Expires: Thu, 01 Jan 1970 00:00:00 GMT
Last-Modified: Tue, 22 Aug 2017 08:15:31 GMT
Content-Encoding: gzip
Content-Length: 7986
Content-Type: text/html; charset=UTF-8

<!DOCTYPE html>
<html lang="de" dir="ltr" class="client-nojs">
<head>
...
<head>
<body>
...
</body>

Entnommen aus: Einsteiger-Tutorial

Status Codes:

  • 200 (OK)
  • 404 (Not Found)
  • 500 (Internal Server Error
  • viele mehr …

Verben bzw. Methoden (insgesamt 9), die Wichtigsten sind:

  • GET (siehe oben)
  • PUT
  • POST
  • PATCH
  • DELETE

GET holt eine Ressource von dem Server. Mit GET kann man auch Formulare abschicken, dann werden die Formularinhalte als Query-String kodiert.

Sowohl PUT als auch POST legen Ressourcen auf dem Server an. Der Unterschied zwischen beiden wird in dem Text http/put-vs-post.txt genauer erklärt. Bei beiden kann man Daten mitschicken (Text, JSON, …), PUT ist zum Anlegen und Modifizieren von Ressourcen mit bereits bekannten URLs (idempotent), POST hingegen kann für beliebige Aufgaben verwendet werden wenn der URL der Resource erst vom Server festgelegt wird, z.B. Formulare, Texte in einem Wiki anlegen, etc. (nicht idempotent).

Mit DELETE werden Ressourcen auf dem Server gelöscht.

APIs mit REST

Beispiel entnommen aus http/rest-api-python-guide.pdf

Verben (GET, PUT, POST, …), Substantive (URL)

  • GET /tasks

    [
 { "id": 3643, "summary": "Wash car" },
 { "id": 3697, "summary": "Visit gym" }
]

  • POST /tasks {'summary': 'Get milk', 'description': '...'}

    200
{ "id": 3792 }

  • GET /tasks

    [
 { "id": 3643, "summary": "Wash car" },
 { "id": 3697, "summary": "Visit gym" }
 { "id": 3792, "summary": "Get milk" }
]

  • OpenAPI (auch als “Swagger” bekannt)

    Mit “OpenAPI” kann man eine REST Schnittstelle (REST API) in einer YAML oder JSON Datei spezifizieren. Daraus läßt sich dann mit einem Compiler (“Swagger Codegen”) Code für den Client und den Server (sog. “server stubs”) generieren.

  • Ein Beispiel für eine REST Schnittstelle ist https://httpbin.org das im Folgenden vorgestellt wird.

Literatur

Tools

httpbin.org

HTTP request/response Service von Kenneth Reitz, der auch das requests Python Modul gemacht hat. Es gibt eine Menge von HTTP REST Endpunkten, die alle eine vordefinierte Funktion habe. So gibt das folgende Kommando einen JSON Body zurück. Die Dokumentation aller Methoden findet man direkt auf https://httpbin.org.

$ curl -i -X GET "https://httpbin.org/json" -H "accept: application/json"
Aufgabenideen

Holen Sie 16 zufällig gesetzte Bytes von httpbin. Tipp: Abschnitt Dynamic Data ansehen.

Curl

https://curl.se

  • “WWW auf der Kommandozeile”

    “command line tool and library for transferring data with URLs (since 1998)”

  • Curl versteht sich mit vielen Protokollen, curl -V zeigt folgende:

    dict file ftp ftps gopher gophers http https imap imaps ldap ldaps mqtt
pop3 pop3s rtmp rtsp scp sftp smb smbs smtp smtps telnet tftp

  • Ein paar Aufrufbeispiele, ich nutze dazu httpbin:

    • Im einfachsten Fall macht curl einen GET Request. Die Option -X GET könnte man auch explizit hinschreiben.

      $ curl https://httpbin.org/json

    • GET Request und Header/Body anzeigen (-i)

      $ curl -i -X GET https://httpbin.org/get

    • PUT Request

      $ curl -X PUT "https://httpbin.org/put"
$ curl -i -X PUT "https://httpbin.org/put?var=wert&var2=wert2"

    • POST Request (beachte einfache und doppelte Anführungszeichen!)

      $ curl -X POST -H "content-type: application/json" -d '{"temp": 25.3}' "https://httpbin.org/post"

    Header Zeilen

    • -H "content-type: text/plain" : Client sendet TEXT bei POST
    • -H "content-type: application/json" : Client sendet JSON bei POST
    • -H "accept: application/json" : Client akzeptiert JSON

  • Mit Curl kann man zum Beispiel für die Gemeinschaft frei zugängliche Daten abfragen (“Open Data”).

    Beispiel 1: Ich hole mir von dem freien Wetter-API https://open-meteo.com die aktuellen Daten für Temperatur und Windgeschwindigkeit. Die Werte werden vom Server im JSON-Format ausgeliefert und mit jq formatiert. Dazu gibt man folgende Kommandozeile ein (nur eine lange Zeile):

    curl "https://api.open-meteo.com/v1/forecast?latitude=52.52&longitude=13.41&current=temperature_2m,wind_speed_10m&dayly=temperature_2m,relative_humidity_2m,wind_speed_10m" | jq .

    Beispiel 2: Tankerkönig - https://creativecommons.tankerkoenig.de

    Einen API-Key bekommen sie schnell wenn Sie auf die angegebene Seite klicken und dort mehrfach auf API-KEY klicken.

    Siehe die Beispieldateien http/tanken.sh und http/tanken.py.

    Andere offene APIs zum Experimentieren sind z.B.

  • Beispiel: Delock 11827, schaltbare Steckdose mit Leistungsmesser. Auf dem ESP8266 Mikrocontoroller im Inneren ist die freie Software Tasmota von Theo Arends installiert. Das Gerät ist bei mir zu Hause unter der IP Nummer 192.168.178.122 bzw. delock-0921.fritz.box erreichbar. Mit folgendem Kommando wird der Leistungsverbrauch abgefragt (der String cmnd=Status%208 bedeutet cmnd=Status 8, %20 steht für ein Leerzeichen).

    $ curl "http://192.168.178.122/cm?cmnd=Status%208"

    Der folgende JSON String wird zurückgeliefert (man könnte ihn mit jq hübsch formatieren):

    {"StatusSNS":{"Time":"2022-01-03T14:52:33","ENERGY":{"TotalStartTime":"2022-01-03T13:17:28","Total":0.017,"Yesterday":0.000,"Today":0.017,"Power":17,"ApparentPower":31,"ReactivePower":26,"Factor":0.53,"Voltage":238,"Current":0.130}}}

    Zum Ein/Ausschalten verwendet man

    $ curl "http://192.168.178.122/cm?cmnd=Power%20toggle"

Literatur zu HTTP und Curl

5.8 MQTT

https://mqtt.org

  • “Message Queuing Telemetry Transport”, 1999 erfunden von Dr. Andy Stanford-Clark (IBM) und Arlen Nipper (Arcom/Eurotech).

    Entnommen von https://www.mqtt.org | vergrössern

  • “Broker”

    Server, der zwischen “Publishern” und “Subscribern” vermittelt. Mosquitto ist ein bekannter Broker (siehe unten).

  • Topics

  • QoS: 0 (höchstens einmal), 1 (mindestens einmal), 2 (genau einmal)

  • TCP Protokoll, Port 1883 (unsicher), 8883 (sicher über TLS)

  • Websockets Protokoll, Port 9001, ermöglicht Zugriff aus Browser

  • Zugriff auf den Broker über

    • CLI Tools
    • Grafische Programme
    • Programmiersprachen (über geeignete Bibliotheken)
    • Web-Seiten (nur über Websockets)

Tools

Tipps

Beispiele

  • mqttx-cli

    $ mqttx-cli sub -h 192.168.178.89 -t hello/world
$ mqttx-cli pub -h 192.168.178.89 -t hello/world -m "Hello from Terminal window 2!"

    Die Debug Option ist --debug.

  • mosquitto_sub, mosquittopub

    $ mosquitto_sub -d -t hello/world
$ mosquitto_pub -d -t hello/world -m "Hello from Terminal window 2!"

  • mqttx-cli über Websockets

    $ mqttx-cli --version
INFO[0000] Broker URI: tcp://192.168.178.89:1883        
https://mqttx.app/changelogs/v1.10.0  

# Websocket connection
$ mqttx-cli conn -l ws -h 192.168.178.89 -p 8080

# Websocket (-l ws), mosquitto is configured with port 8080
$ mqttx-cli sub -l ws -p 8080 -h 192.168.178.89 -t hello/world

# Publisher can send eith with mqtt or ws protocol
$ mqttx-cli pub -h 192.168.178.89 -t hello/world -m "Hello from Terminal window 2!"
$ mqttx-cli pub -l ws -p 8080 -h 192.168.178.89 -t hello/world -m "Hello from Terminal window 2!"

  • Publisher und Subscriber, in Python mit paho-mqtt:

  • MQTT wird beim Autor zur Heimautomatisierung verwendet

    Vergrössern: img/ha-fs8.png

5.9 Mosquitto

Mosquitto ist ein Open-Source MQTT-Broker.

Er wird von der Eclipse Foundation verwaltet, mit vielen anderen Projekten wie z.B. Paho.

Installation auf PC unter Linux

Achtung: Die MQTT und Websocket Verbindungen bei dieser Installation sind unsicher, da der anonyme Zugang erlaubt und auch keine Verschlüsselung (SSL/TLS) verwendet wurde! Somit ist diese Konfiguration nur zum Üben und Testen in einem lokalen Netz geeignet!

sudo apt install mosquitto

Nach der Installation läuft der Broker bereits.

Die mosquitto Konfigurationsdatei ist hier:

/etc/mosquitto/mosquitto.conf

In diese die folgenden Zeilen einfügen, sonst kann man sich nicht von einem anderen Rechner aus verbinden:

listener 1883
password_file /etc/mosquitto/passwd
allow_anonymous true

Falls man auch Websockets aktivieren möchte, dann muss man noch zusätzlich die folgenden Zeilen einfügen:

listener 8080
protocol websockets

Eine leere Passwort-Datei anlegen:

$ sudo touch /etc/mosquitto/passwd

Falls man Änderungen an den Konfigurationsdateien macht sollte man immer den MQTT Broker neu starten mit dem folgenden Kommando:

systemctl restart mosquitto.service

Den Mosquitto Server mit systemd verwalten

Service neu starten:

systemctl restart mosquitto.service

Status abfragen

systemctl status mosquitto.service

Stoppen mit

systemctl stop mosquitto.service

Starten mit

systemctl start mosquitto.service

Logdatei anschauen

sudo less /var/log/mosquitto/mosquitto.log

Clients mosquitto_pub, mosquitto_sub

apt install mosquitto-clients

Hilfe zu mosquitto (man pages)

man mosquitto

Weitere Man-Pages: mqtt, mosquitto-tls, mosquitto.conf, hosts_access, mosquitto_ctrl, mosquitto_passwd, mosquitto_pub, mosquitto_rr, mosquitto_sub, libmosquitto.

5.10 Webhooks

https://www.standardwebhooks.com

Webhooks sind ein nicht-standardisiertes Verfahren um Nachrichten (Events) über HTTP Requests zu schicken. Oft werden die Clients eine Web APIs über Webhooks (Callbacks) benachrichtigt wenn bestimmte Ereignisse eingetreten sind.

Aufgabenidee

Experimentieren Sie mit https://webhook.site. Wenn man auf die Seite geht wird einem ein Zufallslink angeboten, den muss man in die Aufruf-URL geben, so wie in folgendem Beispiel:

$ curl -d '{"test": 43}' -H 'Content-Type: application/json' \
  https://webhook.site/2aecf7ce-2dd1-49cd-83f6-60b965c7ccf1/hook2?foo=bar

5.11 Websockets

https://websocket.org

  • Bidirektionale Kommunikation zwischen Client und Web-Browser

  • RFC6455

  • Definiert Subprotokolle, z.B. WAMP für RPC und Pub/Sub

  • Tools

5.12 LoRa, LoRaWAN

Abbildung 5.1: TTN Übersicht

Übersichtsartikel in der c’t 10 2019 von Jan Mahn Artikel/ct.2019.10-LoRaWAN.pdf

“Meshtastic” (https://meshtastic.org) ist ein freies Projekt das ein Mesh-Netzwerk zum Nachrichtenaustausch erstellt. Es basiert auf dem LoRa Funktstandard. Siehe Artikel in c’t 13 2022 Artikel/ct.2022.13.Meshtastic.pdf.

Genaueres zur Technik von LoRa finden sie an folgenden Stellen

5.13 Python

https://www.python.org

Python Logo

  • Von Guido van Rossum, ab ca. 1989

  • Wenn man eine Programmiersprache lernen möchte, dann Python

    • Einfache Syntax
    • Ideal für Nicht-InformatikerInnen
    • Bedient ein enorm breites Sprektrum, von Allerweltsaufgaben, Excel-Automatisierung bis zu KI Anwendungen, Numerik, Visualisierung, Mikroprozessorprogrammierung (mit Micropython) und vieles weitere.

  • Python Package Index https://pypi.org. Installation mit pip.

  • Cheat Sheets aus dem Buch Python Crash Course von Eric Matthes enthält alle nötigen Grundlagen (28 Seiten): https://ehmatthes.github.io/pcc_3e/cheat_sheets

5.14 Micropython

   

Micropython Logos

Aufgabenideen

Wer sein Heltec ESP32 Board mit einem Web-Server ausstatten will, der in Micropython programmiert ist, der sollte sich folgende Links ansehen:

5.15 mpremote

https://pypi.org/project/mpremote/

          _ __ ___  _ __  _ __ ___ _ __ ___   ___ | |_ ___ 
         | '_ ` _ \| '_ \| '__/ _ \ '_ ` _ \ / _ \| __/ _ \
         | | | | | | |_) | | |  __/ | | | | | (_) | ||  __/
         |_| |_| |_| .__/|_|  \___|_| |_| |_|\___/ \__\___|

                    MicroPython remote control

D. P. George, der Entwickler von Micropython hat mit mpremote auch gleich ein Kommandozeilenprogramm zum interaktiven Arbeiten mit einem Embedded-Board geschrieben. Das Board ist dabei meist über ein USB Kabel an den PC angeschlossen. Es handelt sich dabei um eine serielle Schnittstelle (UART). Unter Linux stehen für serielle Schnittstellen die Gerätedateien /dev/tty*, konkret /dev/ttyUSB0, wobei die Zahl auch 1, 2, und so weiter sein kann.

Doku: https://docs.micropython.org/en/latest/reference/mpremote.html

Installation

$ pip install mpremote

Optionales Konfigurationsfile mit selbstdefinierten Makros: ~/.config/mpremote/config.py

$ mpremote --version
mpremote 1.23.0
$ mpremote help 
$ mpremote --help
$ mpremote mount --help   # Hilfe zu Kommandos
$ mpremote devs   # Geraete anzeigen
/dev/ttyUSB0 0001 10c4:ea60 Silicon Labs CP2102 USB to UART Bridge Controller
$ mpremote connect /dev/ttyUSB0 repl     # oder ...
$ mpremote u0 repl    # siehe mpremote --help

Aus repl aussteigen mit C-].

$ mpremote connect --help
$ mpremote connect list
$ /dev/ttyUSB0 0001 10c4:ea60 Silicon Labs CP2102 USB to UART Bridge Controller
$ mpremote ls
$ mpremote edit main.py
$ mpremote cp :main.py .  # Datei von Mikrocontroller holen
$ mpremote cp -r dir :    # Verzeichnis rekursiv auf Mikrocontroller kopieren
$ mpremote u0 exec "import hhtest"   
$ mpremote u0 exec "import dog; dog.main()"
$ mpremote u0 repl        # Ende mit C-]
$ mpremote mount .        # mount klappt nicht
$ mpremote umount

Entfernte Datei ausgeben. Es geht aber auch mpremote cat <rfile>. Ausser cat kann man auch eingeben: ls, cp, rm, mkdir, rmdir, touch.

$ mpremote fs cat <rfile>

Lokale Python Datei auf den Mikrocontroller uebertragen und dort ausfuehren. Nachher ist die Datei nicht auf dem Mikrocontroller zu finden.

$ mpremote run <file>
$ mpremote reset  # reset device after some delay
$ mpremote df
mount   size    used    avail   use%
        501760  12288   489472  2
flash   501760  12288   489472  2
$ mpremote eval 1/2 eval 3/4
0.5
0.75
$ mpremote exec "import micropython; micropython.mem_info()"
stack: 720 out of 7168
GC: total: 67008, used: 17696, free: 49312
No. of 1-blocks: 210, 2-blocks: 34, max blk sz: 512, max free sz: 3073

User config: .config/mpremote/config.py

Pakete aus der micropython-lib [1] installieren.

$ mpremote mip install aioble 
$ mpremote mip install github:org/repo@branch

Sample config:

# Custom macro commands
commands = {
     "c33": "connect id:334D335C3138",
     "bl": "bootloader",
     "double x=4": {
         "command": "eval x*2",
         "help": "multiply by two"
     }
}

[1] Micropython Lib https://github.com/micropython/micropython-lib

5.16 Node-RED

https://nodered.org

  • Node-RED Programming Guide. Programming the IoT.

    https://noderedguide.com

  • Dashboard

    https://flows.nodered.org/node/node-red-dashboard

  • https://nodered.org/docs/user-guide/writing-functions

  • ct.2018.15.Node-RED.pdf

  • LoRaWAN und Node-RED ct.2021.14.LoRaWAN-TTN-NodeRed.pdf

  • Hier ist eine Anleitung für die zu-Fuß Installation.

    Zunächst Node.JS installieren.

    sudo apt install nodejs

    Deshalb erst mal testen ob man node schon hat:

    node
Welcome to Node.js v12.22.9.
Type ".help" for more information.
>

    Beenden mit Strg-D.

    Auch mal npm eingeben, der sollte mit Node.JS installiert worden sein.

  • Nun mit npm das Node-RED Programm installieren

    sudo npm install -g --unsafe-perm node-red

  • Node-RED starten mit

    node-red

    Das Kommando startet einen Server, der Webseiten ausliefert. Im Web-Browser unter http://127.0.0.1:1880 findet man die Benutzerschnittstelle.

  • In der Benutzerschnittstelle (Web-Browser) von Node-Red installieren (Menue -> Palette verwalten -> Installation).

    • node-red-dashboard
    • node-red-contrib-moment

    Das Dashboard hat einen eigenen Zugangs-Link unter http://127.0.0.1:1880/ui

Unter https://nodered.org/docs/getting-started/local findet man auch noch andere Installationsmethoden.

5.17 Grafana

https://grafana.com

Literatur

5.18 Linux Kommandos

Ich empfehle das freie Buch Linux Essentials des Linux Professional Institute, die aktuelle Version 1.6 in Deutsch mit 451 Seiten ist hier: https://learning.lpi.org/de/learning-materials/010-160/.

5.18.1 Shell Kommandos

  • Im Kurs werden wir öfter in einem Terminal Fenster arbeiten. Hier sehen Sie z.B. das Kommando neofetch, das eine kurze Übersicht zum installierten Linux anzeigt. Das Kommando muss erst installiert werden mit sudo apt install neofetch. Das Terminal-Fenster öffnet sich mit dem Tastenkürzel Strg-Alt-T.

  • Im Terminal Fenster läuft eine Shell, meist ist es die bash.

    • Die Shell hat eine automatische Vervollständigung eingebaut, die man über die TAB Taste triggert. Versuchen Sie also öfter mal auf TAB zu drücken statt z.B. Dateinamen Zeichen für Zeichen bis zum Ende einzugeben.

    • Man kann auch zu früher eingegebenen Kommandos navigieren (History). Im einfachsten Fall geht das mit “Pfeil nach oben”. Smarter geht es mit dem Tastenkürzel Strg-R, danach geben sie die Zeichen ein nach denen sie suchen.

    • Zum Navigieren nach links, rechts, oben und unten gibt es standardisierte Tastenkürzel, einfach mal ausprobieren:

                                Strg-P

      Strg-A      Strg-B            Strg-F    Strg-E

                          Strg-N

      Löschen eines Zeichen geht mit Strg-D.

      Löschen von der aktuellen Stelle bis zum Zeilenende mit Strg-K.

    • Die Shell beendet man mit exit.

  • NICHT ALS ROOT USER ARBEITEN!

    Gründe:

    • Gerade als Anfänger können Sie sehr leicht als root das Betriebsystem kaputt machen, weil sie dann alle Bereiche des Dateisystems schreiben und löschen können.

    • Wenn Sie als root Dateien anlegen, dann können diese nicht mehr als normaler User verändert oder gelöscht werden (ausser man ändert den Eigentümer).

    • Manche Programme weigern sich, als root gestartet zu werden.

    Wenn das Nummernzeichen # als Prompt erscheint, arbeiten sie als root User bzw. Administrator. Sie sollten dann durch exit zum normalen User werden, der Prompt sollte $ sein.

  • Die Tilde ~ steht für das Homeverzeichnis. Mit ls ~ werden die Dateien im Home ausgegeben. Achtung: Dateien die mit einem Punkt beginnen sehen sie nur mit ls -a ~.

  • Sie sollten zumindest die folgenden Kommandos kennen:

    • Verzeichnis wechseln mit cd. Eine Ebene höher kommt man mit cd .. .
    • Kopieren mit cp (copy)
    • Dateien verschieben mit mv (move)
    • Dateien löschen mit rm
    • Verzeichnisse anlegen mit mkdir
    • Verzeichnisse löschen mit rmdir

  • Der nano Editor eignet sich nicht für Python, er verwendet harte Tab Zeichen. Die Konvention ist jedoch, dass eine Einrückung vier Leerzeichen sind.

    Dazu muss man in ~/.nanorc setzen:

    set tabsize 4
set tabstospaces

    Ich empfehle, statt nano den micro Editor zu verwenden. Man installiert ihn mit sudo apt install micro oder holt ihn mit curl:

    $ curl https://getmic.ro | bash

    Micro auf Github

    Cheatsheet https://itsfoss.com/content/files/2023/11/micro-command-line-text-editor-cheat-sheet.pdf

  • Programme installieren. Am besten sie legen ein Verzeichnis bin/ in ihrem Home-Verzeichnis an. Dort hinein stecken sie das ausführbare Programm, zum Beispiel den vorher heruntergeladenen Micro Editor. Abschliessend müssen sie noch die PATH Umgebungsvariable um ~/bin erweitern. Dazu fügt man in ~/.bashrc die Zeile export PATH=$PATH:~/bin ein.

    mkdir ~/bin
mv micro bin

  • Nutzen Sie zum Suchen von Dateien fdfind und zum Suchen von Text in Dateien rg. Diese beiden Tools sind wesentlich einfacher als die normalerweise auf Linux verwendeten find und grep.

    • sudo apt install fd-find   Link
    • sudo apt install ripgrep   Link

5.18.2 Git

https://git-scm.com

Git ist schon seit vielen Jahren die Nr. 1 unter den Versionsverwaltungsprogrammen, nichts führt daran vorbei. Es stammt von Linus Torvalds, der eigentlich schon berühmt genug wegen seines Linux Kernels ist.

Sie können es auf ihrem Linux Rechner installieren mit

$ sudo apt install git

Sie werden im Kurs git nur brauchen um gelegentlich ein Repository zu holen, das geht mit dem Kommando

$ git clone <Clone-URL>

Danach haben sie ein neues Verzeichnis, in das sie wechseln können. Dieses Verzeichnis ist nun ein lokales Git Repository. Wenn Sie genau nachsehen, dann finden Sie mit dem Kommando ls -a darin ein .git Unterverzeichnis, in dem Git alle Dateien zur Versionskontrolle speichert. Prinzipiell hätten Sie nun die Möglichkeit, an den Dateien Änderungen zu machen, und diese unter einer neuen Version zu “committen”, so dass alle Änderungen exakt in dem lokalen .git Verzeichnis mitprotokolliert werden. Wenn Sie die Dateien im Repo nur lesen wollen, dann kann ihnen das aber erst mal egal sein.

git Kommandoübersicht: etc/OSDC_cheatsheet-git-2022.4.7.pdf

Zur systematischen Einarbeitung empfehle ich das freie “Pro Git” Buch, das Sie unter https://git-scm.com/book/de/v2 finden.

5.19 Wokwi

https://wokwi.com

Wokwi ist ein Simulator für Mikroprozessoren inklusive Peripherie, der im Web Browser läuft. Die “User Experience” ist dabei ähnlich wie wenn man ein reales Mikroprozessor-Board am Rechner angesteckt hat.

Wokwi bietet die gängigen Mikroprozessoren wie AVR, ESP32, STM32 und Rapberry Pi RP2024, sowie auch viele bekannte Board wie Arduino Uno, ESP32-DevKitC V4, Raspberry Pi Pico und so weiter. Die Programmierung erfolgt über Arduino C++ oder Micropython. Auch Rust ist als Programmiersprache mittlerweile möglich, siehe https://wokwi.com/rust.

So hat es mir die KI gesagt, hoffentlich stimmt es: “Wokwi wurde von Uri Shaked geschrieben, einem Google-Entwickler, der sich auf Web- und Cloud-Technologien spezialisiert hat. Er ist der Schöpfer und Hauptentwickler von Wokwi, einem Open-Source-Simulator für eingebettete Systeme und IoT-Geräte.”

Den Blog von Uri habe ich selber gefunden: https://blog.wokwi.com/author/uri-2, auch hier: https://urish.org

Ein Blick in die Dokumentation lohnt sich:

5.20 QuestDB / Zeitserien

In den letzten Jahren sind viele neue Datenbanken entstanden, die spezialisiert sind auf die Speicherung von Daten die zeitlich nacheinander entstehen und mit Zeitstempel abgespeichert werden sollen. Das verwundert auch nicht, da es durch Cloud Computing, IoT, Digitalisierung etc. immer mehr Daten gibt. Ein paar Namen sind InfluxDB, TimescaleDB, OpenTSDB, QuestDB, Graphite. Die meisten dieser “Zeitseriendatenbanken” sind im Kern Open-Source Software, jedoch sind fast immer auch kommerzielle Interessen damit verknüpft.

Ich habe mich für den Workshop für die QuestDB entschieden, da sie relativ klein ist und der Open-Source Kern alle wichtigen Features umfasst.

https://questdb.com

Typische Eigenschaften von TSDBs

  • Index über der Zeit
  • Typische Anwendungen: Logs, Sensoren, Börsenticker, Geo-Tracking, …
  • Kontinuierlich über der Zeit aufgenommene Werte
  • Daten werden oft in der Abtastrate verringert (down sampled) oder agreggiert über der Zeit
  • “Gib mir den wöchentlichen Durchschnitt der Sensordaten über das letzte Jahr”
  • Erkennen von Trends über der Zeit
  • Vorhersagen
  • Echtzeit-Alarmierung
  • Anomalieerkennung
  • Visualisierung

Etwas Marketing: https://questdb.com/docs/why-questdb

QuestDB startet man am besten als Container, siehe Abschnitt Container.

QuestDB hat eine Web Anwenderschnittstelle unter http://localhost:9000, Web Console genannt.

QuestDB Web Console groß

QuestDB Web Console groß

Die QuestDB hat drei HTTP Endpunkte

  • Export - http://localhost:9000/exp

    curl -G --data-urlencode \
"query=SELECT * FROM example_table2 LIMIT 3" \
http://localhost:9000/exp

  • Import aus CSV Dateien - http://localhost:9000/imp

    curl -F data=@weather.csv 'http://localhost:9000/imp'

  • SQL Kommandos ausführen - http://localhost:9000/exec

    curl -G --data-urlencode "query=CREATE TABLE IF NOT EXISTS \
trades(name STRING, value INT)" \
http://localhost:9000/exec

Daten in die QuestDB schreiben (ingestion)

Am schnellsten kann man Daten mit dem InfluxDB Line Protocol (ILP) in die QuestDB schreiben, deswegen sollte man diesen Weg wählen.

Ausserdem gibt es noch andere Techniken um Daten zu schreiben:

  • Message broker und Queues (z.B. Kafka, Telegraf)
  • CSV Upload aus der Web Console
  • PostgreSQL Wire Protocol (PGWire) - eher langsam

Daten von der QuestDB abfragen (query)

Die meisten Zeitseriendatenbanken bieten eine Abfrage über das von klassischen Datenbanken bekannte SQL. Meist gibt es nicht-standardisierte Modifikationen von SQL für die speziellen Anforderungen von Zeitserien, hier kocht jeder Anbieter sein eigenes Süppchen.

Es gibt bei der QuestDB folgende Möglichkeiten für die query:

  1. PostgreSQL wire protocol (PGWire)

    Die QuestDB orientiert sich bei SQL an der PostgreSQL Datenbank. In der QuestDB Doku unter https://questdb.com/docs finden Sie eine Referenz aller SQL Kommandos.

    Das PGWire Protokoll kann man aus vielen Programmiersprachen ansprechen, eine Übersicht ist hier: https://questdb.com/docs/pgwire/pgwire-intro. Ich empfehle Python zu verwenden, die folgenden Bibliotheken werden unterstützt: asyncpg, psycopg3, psycopg2.

    Siehe Demo in $WORKSHOP_REPO/questdb.

  2. REST HTTP API

    Endpunkt “exp”: http://localhost:9000/exp

    https://questdb.com/docs/reference/sql/overview/#rest-http-api

  3. In der Web Console kann man interaktiv SQL Kommandos abgeben. Eignet sich gut zum Experimentieren.

Zukünftig kommt noch die Abfrage über Apache Parquet hinzu, siehe https://parquet.apache.org. Das ist aber nur im Bereich von anspruchsvollen Projekten von Interesse, wenn sehr grosse Datenmengen schnell abgefragt werden müssen.

Doku: https://questdb.com/docs

Literatur

  • Der c’t Artikel behandelt zwar den Konkurrenten InfluxDB, bietet aber auch einen guten Überblick zu Zeitserien-Datenbanken, Artikel/ct.2019.05-InfluxDB.pdf.

5.21 Ntfy.sh

https://ntfy.sh

  • Android/Mac App von Philipp C. Heckel (frei, ohne Werbung!)

  • Benachrichtigungen sind HTTP Requests, z.B. über curl:

    $ curl -d "Hallo" ntfy.sh/alp_iot_workshop_2025

    Der URL steht sowohl für das Thema als auch für das Passwort. Jeder der den URL kennt kann eine Nachricht hinschicken.

  • CLI tool (Go) https://github.com/binwiederhier/ntfy

Doku

5.22 Container

https://www.docker.com, https://docs.docker.com/compose

Die folgenden Dienste habe ich vorbereitet damit man sie beim Workshop über docker-compose starten kann. In $WORKSHOP_REPO/docker_test sind kurze Skripte und Programme die zeigen wie man einige der Dienste verwendet.

Wie man Docker und Docker Compose installiert und eine kurze Anleitung finden Sie weiter unten.

  • Mosquitto

    cd $WORKSHOP_REPO/docker/mosquitto
docker-compose up -d

    Der Container hat den Namen alp_iot_mosquitto. Die Konfiguration des Dienstes ist in docker/mosquitto-vol/config/mosquitto.conf, der anonyme Zugang ist erlaubt.

  • Webhookd

    cd $WORKSHOP_REPO/docker
docker-compose -f webhookd.yml up -d

  • Node-RED

    cd $WORKSHOP_REPO/docker

docker-compose-2 -f nodered.yml up -d
docker exec -it alp_iot_nodered bash -c "npm install node-red-dashboard && \
    npm install node-red-contrib-moment"
docker restart alp_iot_nodered

    Die docker exec ... Anweisung installiert zwei Node-RED Erweiterungen. Alle drei Kommandos sind in nodered.sh zusammengefasst.

  • Grafana

    cd $WORKSHOP_REPO/docker
docker-compose -f grafana.yml up -d

  • QuestDB

    cd $WORKSHOP_REPO/docker
docker-compose -f questdb.yml up -d

Sie müssen zunächst auf ihrem Rechner Docker und Docker-Compose installieren.

  • Docker installieren Sie über sudo apt install docker.io

  • Docker-Compose erleichtet die Arbeit mit mehreren Containern. Man schreibt die Konfiguration der Container in eine YAML Datei [4] und läßt diese Datei von docker-compose ausführen. Im Hintergrund erledigt die Arbeit immer noch docker, deshalb kann man auch die üblichen Docker Kommandos auf die erzeugten Container anwenden.

    Sie installieren docker-compose in der Version 1.x mit sudo apt install docker-compose. Diese Version ist in Python geschrieben.

    Ich empfehle jedoch, das Programm docker-compose in der Version 2.x zu installieren, man findet es auf https://github.com/docker/compose. Es ist in Go geschrieben, deshalb besteht es aus nur einem grossen Binärfile.

Zustände eines Containers

      Existiert  create     Existiert,   start   Container
      nicht     ------->    läuft aber   ----->  läuft
                   rm       noch nicht   <-----
                <-------    (gestoppt)   stop
                   rm -f
                <------------------------------
                              run
                ------------------------------->

Damit ein Container erzeugt und gestartet werden kann muss ein Container-Image vorhanden sein. Mit docker pull ... holen Sie ein Image, docker images zeigt die vorhandenen Images an.

Für unseren Kurs reicht es völlig aus, wenn wir vorhandene Images holen und davon Container erzeugen. Man kann mit Docker aber auch eigene Images erzeugen, dazu ist dann die Konfigurationsdatei Dockerfile nötig.

Docker und Docker-Compose Kommandos

  • Hilfe bekommt man mit

    docker --help

    Die Version wird mit docker version ausgegeben.

  • Nach Container-Images auf Docker Hub suchen (https://hub.docker.com)

    docker search <string>

  • Image holen

    docker pull

  • Vorhandene Images auflisten

    docker images

  • Container erzeugen und laufen lassen (-i: interactive, -t: terminal, -p: host port:container port, -v: volume)

    docker run -it -p 1880:1880 -v node_red_data:/data --name mynodered nodered/node-red:latest

    Mit der zusätzlichen Option -d kann man den Container im Hintergrund laufen lassen (detach).

  • Laufende Container auflisten

    docker ps

  • Alle Container auflisten (auch gestoppte)

    docker ps -a

  • Logfile eines Containers anzeigen

    docker logs <id>

  • Container entfernen

    docker rm <id>

  • Alle Container (auch laufende) entfernen

    docker rm -f $(docker ps -aq)

  • Info zu Container ausgeben

    docker inspect <id>

  • Statistik zu Ressourcenverbrauch

    docker stats <id>

  • Image löschen

    docker rmi <image>

Docker-Compose

  • Hilfe bekommt man mit docker-compose --help. Die Version wird mit docker-compose version ausgegeben.

  • Container der/die in der .yml Datei definiert sind starten. Wenn die Konfigurationsdatei docker-compose.yml heißt, benötigt man die -f Option nicht. Es dürfen auch mehrere -f Optionen angegeben werden. Die -d Option bedeutet detached.

    docker-compose -f docker-compose-node-red.yml -p myNoderedProject up -d

  • Container herunterfahren

    docker-compose down

  • Laufende Dienste anzeigen

    docker-compose ps

Literatur

Das meiner Meinung nach beste Docker-Buch für Anfänger ist das hier: James Turnbull, The Docker Book, https://dockerbook.com.

Wer auch gerne mal Alternativen anschaut sollte sich Podman (https://podman.io) vornehmen. Es ist Kommando-kompatibel zu Docker (bis auf winzige Ausnahmen) und es funktioniert anders als Docker ohne Daemon im Hintergrund. Podman läuft komplett unter der Kennung des angemeldeten Users (“rootless”). Es gibt auch podman-compose als Ersatz für docker-compose.

Im folgenden finden Sie das freie Buch Podman in Action von Daniel Walsh (2023) und ein Cheat Sheet:

Das Podman Logo - ist es nicht schön?

Literatur

[1] https://historyofcomputercommunications.info/interviews/Gordon-Bell

[2] https://vanhunteradams.com/Protocols/UART/UART.html

[3] https://de.wikipedia.org/wiki/RS-232

[4] https://de.wikipedia.org/wiki/YAML

[5] https://de.wikipedia.org/wiki/Microchip_AVR