Posts mit dem Label Docker werden angezeigt. Alle Posts anzeigen
Posts mit dem Label Docker werden angezeigt. Alle Posts anzeigen

Mittwoch, 30. September 2026

Sternwarte im Docker Container

Noch eine Sache die ich mir mit Claude generiert habe ist eine Webseite die mir relevante Informationen zum Thema Weltraum zeigt.

  • Wie siehts mit der Bewölkung bei der Stündlich Schritten aus in der Nacht. Weil mit dem Teleskop eine klare sicht erfordert.
  • Wo befindet sich gerade die Raumstation ISS. Vielleicht kann man die Station so als Lichtpunkt am Himmel erkennen.
  • Wie hoch ist der Kp-Index. Interessant wenn mal wieder Nordlichter zu sehen sein sollte. Zwar sind die großen Sonnenaktivitäten vorbei, aber man weis ja nie, ob etwas unvorhergesehenes kommt und dann will ich das schon Rechtzeitig erfahren.
  • Raketenstarts. Wer weis. Bisher habe ich die Raketenendstufen am Himmel gesehen, von SpaceX.
  • NASA Bild des Tages. Ich mag Weltraum Bilder.

Das ganze läuft als Docker Container auf meinem Raspberry Pi, auf dem bereits das Smarthome ausgeführt wird.

So, nun ist das ja nicht so, dass ich immer jeden Tag daran denke, auf die Webseite zu schauen. Daher kam noch die Ergänzung, dass ein ESP32-C3 die Docker Container einen Wert abfragt und dann eine RGB LED ansteuert. Für jedes Thema habe ich eine Farbe gewählt und somit muss ich nicht mal ein Gerät starten, um die Webseite abzurufen.

An der Stelle käme der Punkt, wo ich die Sourcen posten würde, aber viel Interessanter wäre der Promt. Zudem kann jeder einen Kostenlosten Account erstellen und sich ebenfalls solch einer Docker Container Anwendung Generieren. Am Ende bekommt man nicht nur die Sourcen zum herunterladen, sondern auch die Anleitung.

Der Promt:

Weltraum-Seite in Kombination mit einem ESP32-C3 an dem eine RGB LED (WS2812b) angeschlossen ist.
Weil ich selbst auch eine Teleskop habe, interessiere ich mich auf gute Bedinungen wie Wetter und Weltraum Abhängige Ereignisse.
Gerne auf der Übersicht folgende Inhalte einsetzen:

  • Posittion der ISS Raumstation und wenn möglich das aktuelles Land anzeigen, über das gerade die Raumstation liegt
  • Raketenstarts, die möglicherweise in Europa zu sehen sein könnten am Himmel. Z.B. von SpaceX konnte ich einmal das beobachten.
  • Sonnenstürme. Bezüglich wenn die Erwartung von Nordlichter sehr hoch ist.
  • Das NASA Bild des Tages.

Für die Webseite sollte ein Zugriffspunk genannt werden, damit ich mit dem ESP32-C3 abfragen kann, ob gerade etwas interessantes anliegt. Dabei reicht ein URL Abgriff mit Rückgabe eines Farbwertes von RGB. Dann bin ich nicht wirklich von dem ESP32-C3 abhängig, sondern könnte auch andere System nutzen, die darauf zurückgreifen könnten.
Der Abrufende Farbwert hat stellenvertretene Hinweis auf die genannten Punkte.

  • Grün für ISS, wenn sich die Raumstation über Deutschland befindet.
  • Lila, wenn Raketenstart in den nächsten 24 Stunden ansteht.
  • Blau für die Meldung von Nordlichtern

  

 

Montag, 6. April 2026

Problem mit PostrgreSQL auf Raspberry PI

Eigentlich wollte ich eine menge Programme auf einem Raspberry Pi installieren und das am besten über eine Docker Compose Datei einrichten. Aber bevor ich eine Finale Docker Compose Datei erstellen kann, muss ich mich mehr mit den Ziel Programmen auseinandere setzen.

Zugegeben kann eine Einrichtung der Anwendung auch über KI Chats abgefragt werden und gewisser maßen ließe sich mit dem richtigen Prompt, das Lernen neuer Technologien neu gestalten. Also Warum noch ein Blog schreiben? KI Chat geben oft nur das Ergebnis, was oft in der Masse genutzt wird und wenn eine Lösung Obsolete ist, hatte ich oft die alten Lösungen erhalten, die selbstverständlich nicht funktionierten. Dem KI Chat fehlt noch die Kreative Lösungen zu erarbeiten. Egal wie gut oder Schlecht der geschriebene Prompt ist, man tritt an diese Grenze und aus der KI Hilfe wird schnell zur Bremse.

Setup

  • Raspberry Pi 4 mit 4GB Arbeitsspeicher
  • RaspbianOS
  • Docker for Linux an Arm
  • Postgres Datenbank

 

Anforderung

Die Datenbank Postgres soll auf dem Raspberry Pi installiert werden und über das Netzwerk erreichbar sein. Zudem dürfen die Daten nicht weg sein, nach einem Neustart durch updates oder Stromausfall des Raspberry Pi. Weil später noch weiterere Programme auf dem Raspberry Pi ausgeführt werden, darf die Datenbank maximal 30% der CPU Leistung beanspruchen. 

Zusatz ist mein Problem, warum ich wieder ein Blogpost dafür schreibe. Daher die Lösung des Problemfalls beschreiben. 


Vorbereitung

Die Einrichtung der Postgres Datenbank in Docker kann komplett in eine Docker Compose festgehalten werden. Einzig und alleine ist sich mit Docker Compose auseinander zusetzen und anschließend die Inhalte zu kommentieren.

Fangen wir an, einen Ordner anzulegen, in dem die Docker Compose für Postgres abgelegt werden. 

sudo mkdir SetupPostgresql  

Anschließend in den Ordner wechseln

cd SetupPostrgresql  

Und dann mit der Anwendung Nano erstellen wir an eine neue Docker Compose Datei. 

sudo nano docker-compose.yaml

Mit dem bestätigen des Commands, wechselt die Ansicht in den Textbearbeitungswerkzeug Nano.

Den Inhalt füllen wir nun mit dem Typischen YAML Code.  Hier nicht vergessem den Zugang mit Benutzername und Passwort festzulegen. 

version: '3.8'

services:
  postgres:
    image: postgres:latest          # installiert die aktuell verfügbare version.
    container_name: postgres_rpi
    environment:
      POSTGRES_USER: dein_benutzername          # muss eingerichtet werden
      POSTGRES_PASSWORD: dein_sicheres_passwort # muss eingerichtet werden
      POSTGRES_DB: deine_datenbank
    volumes:
      - postgres_data:/var/lib/postgresql/data  # stellt sich, dass die Daten bleiben
    ports:
      - "5432:5432"                 # Der Port, auf die Datenbank erreichbar ist.
    deploy:
      resources:
        limits:
          cpus: '0.3'               # Maximale CPU-Auslastung auf 30% begrenzen
    restart: unless-stopped         # Verfügbarkeit nach dem neustart. 

volumes:
  postgres_data:                    # stellt sicher das die Daten bleiben.

Nach dem Einfügen wird mit dem Befehl STRG + o mit anschließenden ENTER gespeichert und mit STRG + x wird die Anwendung Nano verlassen und wechselt wieder in die Terminal Ansicht.

Nun kann mit der fertigen Datei die Installation durchgeführt werden, um den Container zu starten.

sudo docker-compose up -d

 Falls folgende Meldung kommt, dann das binde Strich weg lassen.

 

Wenn die Ausführung funktioniert hat, dann sollte folgendes als Ergebniss ausgegeben werden.


Zugriff prüfen

Zunächst kann geprüft werden, ob der Docker Container wirklich  ausgeführt wird. 

sudo docker ps

Wenn im folgenden Bild der Status mit "Restarting (1) ..." steht, dann funktioniert der Container nicht und startet in diesen Fall immer wieder neu.

 

Fehlerursache

Um nach dem Problem zu schauen, hilft der Blick in den Docker Logs. Im Command ist darauf zu achten, den Log auf einen Docker Container zu filtern.

sudo docker logs postgres_rpi

Wie bereits in meinem Intro Bild, erschien bei mir der Fehler, dass mit PostgreSQL Version 18 der Pfad zum Persistieren sich geändert hat.

 

Klar ist, dass der Pfad zu ändern ist. Also kehren wie in die Docker-Compose Datei zurück.

sudo nano docker-compose.yaml

Folgende Anpassung bzw. Ergänzung sollte gesetzt werden vor dem Eintrag "volumes".

# WICHTIGE Anpassung und hilft auch bisherige Pfade zu verwenden.
PGDATA: /var/lib/posgresql/data

Weil mir eine Beschreibung zu lang werden würde, habe ich ein Bild vom YAML angelegt und die Stelle Markiert, das einfach Zeigt, wo der Eintrag gesetzt werden soll.

 

Anschließend Speichern mit STRG + o und mit Enter bestätigen. Mit STRG + x die Anwendung Nano beenden.

Probieren wir die Änderung aus.

sudo docker compose up -d

Folgendes Ergebnis kam in meinem Fall. Am Status ist zu sehen, dass nun die Datenbank funktioniert.

Zugriff von einem anderen System prüfen 

Für den Zugriff verwende ich von Jetbrains die Anwendung DataGrip, das für verschiedene Datenbanken verwendet werden kann. Für das einrichten einer neuen Datenbank muss Benutzername und Passwort gesetzt sein, sowie die IP Adresse und Port.

Mit "Test Connection" kann dann geprüft werden, ob die Verbindung zur Datenbank funktioniert.

 

Hat das geklapp, kann nun auf die Datenbank "developer_data" auf dem Raspberry Pi zu gegriffen werden.

 

Abschließend

Vielleicht suche ich einfach nach den falschen Begriffen. Mit Google habe ich die Behebung der Fehlerursache nicht gefunden und der lange Eintrag in Github, war für mich mühselig. Besonders, wenn man zu Müde ist. Hilfreich war das Tool Notebook LM in dem man den Link eingibt und dann mit der KI Chat fragen stellen kann. So kam ich relativ schnell auf eine Lösung, wofür ich sonst deutlich länger gebraucht hatte.

Am Anfang hatte ich bereits schon einen KI Chat probiert und festgestellt, dass das Thema wohl zu neu ist oder das es eins von den Dingen ist, wo einem der KI Chat hinhält, um möglichst viele Tokens zu verbrauchen. Das ist mir schon öfter aufgefallen, dass die Lösung schon nach zwei drei Fragen hätte erledigt sein könne. Daher mein anderer Ansatz mit Notebook LM.

Noch was. Ich hätte das Problem weg lassen können und gleich den Lösungsansatz schreiben können. Den YAML Code habe ich über den KI Chat generiert und erkannte gleich ein Problem einer Hinhalte Taktik von KI Chats oder vielleicht doch "Zufall", dass ich schon letztes jahr festgestellt habe. 

 

Quellen:

https://github.com/docker-library/postgres/pull/1259 

Montag, 20. Mai 2024

Hello World, Blazor im Container auf Raspberry PI


Das liegt schon etwas her, dass ich damit anfangen wollte ein Blog Eintrag über das Thema Docker zu schreiben.

Die Ursprungsidee ist, dass auf dem Raspberry PI die Webseite gehostet wird und darüber der Text eingegeben wird und später über eine Desktop Anwendung auf dem Raspberry PI wieder gegeben wird auf dem Bildschirm. Doch zunächst muss die Webseite in einem Container gestartet werden mit einem ARM System.

 

Benötigt wird:

  • Raspberry PI 2 oder aktueller
  • RaspbianOS
  • Installation .NET 7 auf RaspbianOS
  • Docker installtion auf Raspbian

 

Beispiel Webseite

Auf dem Raspberry PI soll eine Blazor Web Anwendung gehostet über einen Docker Container gehostet werden.

 

Vorbereitung

Für den Zugriff auf den Raspbian verwende ich Putty und die SSH Verbindung.

 

Docker installieren

Ein Befehl reicht, um die aktuelle Version von Docker zu installieren auf dem Raspberry PI

 sudo curl -fsSL https://get.docker.com | sh  

 

Nach installation kann die Docker version abgefragt werden.

 docker --version   




.NET installieren und prüfen

Mit dem folgenden Befehl wird das .NET installiert auf RaspbianOS und kann einige Minuten dauern. In meinem Fall habe ich .NET 7 installiert und musste die Version nicht direkt eingeben.

 curl -sSL https://dot.net/v1/dotnet-install.sh | bash /dev/stdin --channel STS 

War die Installation erfolgreich, dann sollte das wie im folgenden Bild aussehen.


Damit der befehlt von das Abfragen der Versionsnummer funktioniert, sollte die Pfadauflösung geändert werden.

 echo 'export DOTNET_ROOT=$HOME/.dotnet' >> ~/.bashrc  
 echo 'export PATH=$PATH:$HOME/.dotnet' >> ~/.bashrc  
 source ~/.bashrc  

Die Versionsnummer abfrage sollte ohne "sudo" eingabe funktionieren.

 dotnet --version  

 



Blazor Projekt erstellen

Zum testen kann direkt auf dem Raspberry PI ein Blazor Projekt erstellt werden. Natürlich macht das mehr sinn, sein Projekt auf dem System zu erstellen, wo man selbst auch Programmiert.

 

Da auf dem RaspbianOS kein Visual Studio 2022 habe, kann ich mit Hilfe von .NET das Projekt direkt per Befehl erzeugen. Aber zunächst muss ein Ordner erstellt werden, in der später auch die Dockerfile Datei hinzugefügt wird.

 

Dann anschließend in das Verzeichnis wechseln: cd ExampleBlazorApp


Mit dem erstellen der Blazor WebAssembly Standalone Anwendung, wird wiederum ein Verzeichnis erstellt. 

 dotnet new blazorwasm -o ExampleBlazorProject  

Das erstellen dauert ca. eine halbe Minute. Wurde das erstellen zum ersten mal verwendet, werden am Ende deutlich Mehr Informationen angezeigt als im folgenden Bild.

 

Jetzt noch die Dockerfile erstellen im selben Verzeichnis mit dem Editor 'nano':

 nano Dockerfile 



Inhalt der Dockerfile. Hier ist darauf zu achten, dass die Dockerfile im selben Ordner steckt wie der Projekt Ordner selbst:

 # Build stage  
 FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build  
 WORKDIR /src  
 # Copy the .csproj file and restore the dependencies  
 COPY ["ExampleBlazorProject/ExampleBlazorProject.csproj", "ExampleWebAssembly/"]  
 RUN dotnet restore "ExampleBlazorProject/ExampleBlazorProject.csproj"  
 # Copy the rest of the application code  
 COPY . .  
 WORKDIR "/src/ExampleBlazorProject"  
 RUN dotnet build "ExampleBlazorProject.csproj" -c Release -o /app/build  
 RUN dotnet publish "ExampleBlazorProject.csproj" -c Release -o /app/publish  
 # Final stage  
 FROM nginx:alpine AS final  
 COPY --from=build /app/publish/wwwroot /usr/share/nginx/html  
 EXPOSE 80  
 CMD ["nginx", "-g", "daemon off;"]  

 


Mit STRG + X kann die Anwendung dann beendet werden. Bevor jedoch die Anwendung 'Nano' geschlossen wird, wird abgefragt, ob die Änderung gespeichert werden soll.


Mit Y oder J Taste drücken…



… und anschließend Enter-Taste drücken. Fertig.

 

Nun sollte im Verzeichnis die Datei 'Dockerfile' vorhanden sein.


 

Nun sollte sich das Beispiel Projekt als Docker Container erstellen lassen. Der Name des Container muss komplett klein geschrieben sein.

 sudo docker build -t exampleblazorcontainer .  

Die Ausführung dauert eine weile (5 bis 6 Minuten), da einige Dinge Extrahiert werden und Inhalte geladen werden.



Nun der letzte Schritt, der Zeigt, dass man eine Blazor Anwendung komplett auf Linux erstellen kann.

 sudo docker run -d -p 8081:80 --name myblazorapp exampleblazorcontainer

Wenn alles geklappt hat, sollte über die Docker abfrage dann sichtbar sein, dass der Container läuft.




Schlusssatz

Ich hatte ganz vergessen, dass man seit .NET Core, eine Web Anwendung komplett in Linux aufstellen kann. Und so wie das jetzt ist, finde ich die Lösung mit Blazor sehr gelungen. Der Weg ist selbst nicht intuitiv und musste daher schon einiges Ausprobieren und recherchieren. Hilfreich war natürlich auch ChatGpt, welches sich wieder als sehr gutes Werkzeug macht und Zeit erspart, unzählige veraltete Forum Einträge durch zu lesen.

Eigentlich wollte ich das mit .NET 8. Doch zu diesen Zeitpunkt (20.05.2024) hatte ich noch Probleme mit der Version und hatte mich auch nicht länger beschäftigt.

 

Resourcen

Bereitstellen von .NET-Apps auf ARM-Single-Board-Computern - .NET | Microsoft Learn

ChatGpt

Sonntag, 19. April 2020

GO(lang) on Raspberry Pi


Kleine Anwendungen können ganz gut auch auf kleinen Systemen laufen. Da ich mich in letzter Zeit öfter mit GO (Golang) auseinandersetze, wende ich mich ein wenig von Windows ab und schaue seit längerer Zeit mal wieder über den Tellerrand. Hängen geblieben bin ich in den verfügbaren Linux Betriebssysteme für Raspberry PI und dem Einsatz von Docker.

Mit Docker kann man alles machen. Naja, nicht alles alles. Mein Kaffee muss ich immer noch selber kochen, außer ich schreibe eine Anwendung und baue einen Treiber mit Sensoren und Aktoren, um die Kaffeemaschine zu kontrollieren. Dann sollte das auch mit Docker gehen. Oder ich schicke der Frau eine Nachricht und bitte um Kaffeenachschub. Aber fangen wir mit etwas einfacherem an.

Wir brauchen dazu:

Anforderung
Am Ende soll auf dem Raspberry Pi ein Webservice laufen, der in einem Docker Container gestartet wird. Der Dienst soll von einem anderen PC mit einem Browser im lokalen Netzwerk aufrufbar sein und schließlich eine Testwebseite wiedergeben.

Webservice entwickeln in GO
Einen Webservice in GO zu schreiben ist sehr übersichtlich. In C# mit .NET Framework habe ich deutlich mehr Codes geschrieben, bis endlich ein Webservice lief. Zudem fällt mir das Wegdenken von Programmiergewohnheiten schwer, die eigentlich nicht sein müssen. Man spricht auch oft von Boilerplate-Code.

Kommen wir zu dem GO Code mit dem geschriebenen Webservice. Nachdem wir im Projektordner eine neue Datei angelegt haben mit dem Namen 'main.go', geht das Schreiben mit dem Code los, bzw. einfach den folgenden Code nach dem Absatz kopieren.
Im Detail zu der Sprache GO kann ich die Seite von Golang 'A Tour of Go' empfehlen. Dort lernt ihr alle Grundlagen zu der Sprache und könnt die Eingaben direkt im Browser prüfen.
In der 'main()'-Funktion startet die Anwendung den Webservice. Kommt ein URL Request rein, wird durch die Handler Function ‚http.handleFunc‘ der Delegat ‚webserviceHandler‘ ausgeführt. Dieser kann den eingehenden Request verarbeiten. Doch für dieses Beispiel kommen wir ohne Parameter aus. Stattdessen wird eine HTML Seite eingelesen und als Response zurückgegeben.

 package main  
 import (  
      "fmt"  
      "io/ioutil"  
      "net/http"  
 )  
 func main() {  
      fmt.Println("start webservice")  
      http.HandleFunc("/", webserviceHandler)  
      http.ListenAndServe(":5000", nil)  
 }  
 func webserviceHandler(w http.ResponseWriter, r *http.Request) {  
      webside, err := ioutil.ReadFile("index.html")  
      if err != nil {  
           fmt.Println(err)  
           return  
      }  
      fmt.Fprintf(w, string(webside))  
 } 




Lokal den Service ausprobieren
An der Stelle sollte der Code bereits ausführbar sein. Wenn jetzt F5 zum Ausführen gedrückt wird, dann sollte Lokal mit einem Browser der Webservice mit der Adresse 'http://localhost:5000' aufrufbar und das ‚Hello World Webseite‘ zu lesen sein.

Dockerfile anlegen
Damit der Webservice auch im Docker Container funktioniert, ist relativ wenig zu tun. Relativ, an der Stelle habe ich lange gesucht und mich lange mit Docker auseinandergesetzt, um am Ende die einfach aussehende Dockerfile zu schreiben. An der Stelle kann ich nur empfehlen, die einzelnen Befehle nach zu lesen, die für die Dockerfile verwendet werden können. Dockerfile Preference https://docs.docker.com/engine/reference/builder/
Die Dockerfile kommt in dasselbe Verzeichnis, wie die Datei mit dem GO Code. Die Einträge mit 'LABEL' sind optional und können auch weggelassen werden.

 # Initialisiert die Bereitstellung und   
 # legt das Basis Image mit nachfolgenden Anweisungen an  
 FROM golang:onbuild  
 # label of maintainer  
 LABEL maintainer="Codexzier"  
 LABEL version="1.0"  
 LABEL description="A mini messenger server with based user."  
 # legt das Verzeichnis an für die Ausführung  
 WORKDIR /app  
 # kopiert die neuen dateien in den container  
 COPY . .  
 # Führt das Image aus und übergibt das Ergebnis für die Zielumgebung  
 RUN env GOOS=linux GOARCH=arm GOARM=5 go build -o main .  
 # Freigabe der Portnummer auf das der docker container zuhört  
 EXPOSE 8002  
 # Anweisung für den Ausführenden Container  
 CMD ["./main"]  

Docker Image erstellen
Ab dieser Stelle sollte Docker installiert und gestartet sein. Ihr solltet auch einen Account haben, damit das Image anschließend auf Dockerhub geladen werden kann.
In Visual Studio Code öffnen wir zunächst ein Terminal. Hier sollte aktuell das Verzeichnis aufgerufen sein, worin sich der Programmcode, Webseite und die Dockerfile befinden. Hier gibt ihr folgenden Command ein und am Ende den Punkt nicht vergessen:

docker build -t <image name> .




Nun sollte eine Folge von Arbeitsschritten erfolgen bis dann am Ende Successfully build mit einer kryptischen ID steht und ggf. mit einigen Warnhinweisen.





Bevor auf Dockerhub geladen werden kann, muss noch das Image tagged gesetzt werden (Image tagged, da bin ich nicht sicher ob man das so beschreiben kann). Statt wie bei mir mit Codexzier, müsst ihr euren Docker Username verwenden.

docker tag <tag name>:latest <docker username>/<ziel name>:latest





Nun kann das Image auf Dockerhub hochgeladen werden. Auch hier verwendet ihr euren Username von Docker.

docker push < docker username >/< ziel name >:latest




Nach ein paar Sekunden sollte der Upload abgeschlossen sein. Wenn ihr euch auf Dockerhub https://hub.docker.com/ eingeloggt habt, sollte euer Image in euren Repositories zu finden sein.




Das Image steht bereit und kann vom Zielsystem abgeholt werden. Auf Dockerhub könnt ihr weitere Informationen zu eurem Image hinterlegen. Zum Beispiel, was der Inhalt ist und welche Aufgabe die Anwendung erfüllt. Wenn ihr wollt, dass nur ihr das Image sieht, dann kann hier auch auf Private umgestellt werden. Interessant dürfte auch das Automated Builds sein, aber das wäre wieder ein eigenes Thema.

Docker auf dem Raspberry Pi
Das Beispiel zeigt den Einsatz von Docker mit dem Betriebssystem Raspbian. Von Haus aus ist Docker nicht installiert, ebenso wenig wie Docker-Compose. Im Netz finden sich einige Beschreibungen, daher habe ich den Part hier ausgelassen.

Hinweis: Bei mir muss ich kein "sudo" vor jeden command eingeben.

Um nun das Image herunter zu laden, muss folgender Command ausgeführt werden:

docker pull <docker username>/<image name>




Nach dem Download wird das Image mit einer Image-ID angelegt. Die brauchen wir, um die Anwendung zu starten. Mit folgendem Befehl bekommt ihr alle vorhandenen Images ausgeben.

docker image ls

In der Spalte zu IMAGE ID steht, die ID zu eurem heruntergeladenen Image. Die hier angezeigte ID wird Lokal erzeugt und sollte eine andere ID abbilden.
Mit dem nächsten Command, setzt ihr die entsprechende ID am Ende ein:

docker run --publish < port number to pulish >:< internal port number > -t < image id >



Die gewählte Port 8003 im Beispiel kann frei gewählt werden, wenn die Portnummer nicht von einer anderen Anwendung bereits verwendet wird. Die IP Adresse von Raspberry könnte ihr unter Raspbian auslesen, in dem ihr mit der Maus über das Netzwerk Symbol fährt. Mit der von eurem Raspberry Pi IP Adresse und der gesetzten Portnummer, solltet ihr auf eurem PC, Notebook und Smartphone auf den Raspberry zugreifen können und die Webseite 'Hello World!' erhalten.


Langer Weg für die Bereitstellung
Die Bereitstellung ist etwas lang, aber durch die Docker-Umgebung auf eine einheitliche Ebene gebracht. Das Gleiche sollte nicht nur mit GO funktionieren, sondern auch mit anderen Sprachen. Und Dank Docker können wir einen Service schreiben, der praktisch auf allen Systemen bereitgestellt werden kann.

Wie immer ist der fertige Code auf meinem Repository verfügbar

Ameisen Simulation und andere Dinge

Wer lange sich schon mit C# beschäftig, hat sicherlich schon mal was von AntMe gelesen oder gehört. Diese Idee hatte ich aufgegriffen und mi...