Wie könnte man dann systemabhängige Konfiguration machen? Also zum Beispiel IP Adressen…
- User
Wie könnte man dann systemabhängige Konfiguration machen? Also zum Beispiel IP Adressen und Ports?
Assistant
Das ist eine hervorragende und wichtige Frage! Systemabhängige Konfiguration ist der Schlüssel zu einem robusten und flexiblen Deployment. Hier sind die gängigsten und besten Methoden, um IP-Adressen, Ports und andere umgebungsabhängige Parameter zu verwalten, aufgeschlüsselt nach den zuvor besprochenen Deployment-Strategien.
Das Grundprinzip ist immer: Konfiguration von Code trennen.
1. Docker Compose (Empfohlener Weg)
Docker Compose ist hierfür hervorragend geeignet, da es mehrere Mechanismen bietet, um Umgebungsvariablen und Konfigurationsdateien in deine Container zu injizieren.
a) Umgebungsvariablen (
environment&.envDateien)Dies ist der bevorzugte Weg für viele dynamische Parameter wie Broker-Hostnamen/IPs, Ports, API-Schlüssel usw.
-
Im
docker-compose.ymldirekt (für statische oder nicht sensible Werte): Du kannst Umgebungsvariablen direkt imdocker-compose.ymlunter demenvironment-Schlüssel für jeden Service definieren. Das ist nützlich, wenn ein Wert über alle Umgebungen hinweg gleich ist oder direkt im YAML dokumentiert werden soll.version: "3.9" services: mosquitto: image: eclipse-mosquitto:latest ports: - "1883:1883" volumes: - mosquitto_data:/mosquitto/data - ./mosquitto_config:/mosquitto/config # Hier kommen Konfigurationsdateien rein robot_adapter_kuka: build: ./robot_adapter_kuka depends_on: - mosquitto environment: - MQTT_BROKER_HOST=mosquitto # Service-Name ist der Hostname im Docker-Netzwerk - KUKA_ROBOT_IP=192.168.1.101 # Externe IP des physischen Kuka-Roboters - KUKA_ROBOT_PORT=54321 networks: - iot-network dashboard: build: ./react-dashboard ports: - "3000:80" depends_on: - mosquitto environment: - VITE_MQTT_BROKER_HOST=mosquitto # Für React/Vite-Apps: Präfix VITE_ ist wichtig - VITE_MQTT_BROKER_PORT=1883 networks: - iot-network networks: iot-network: driver: bridge volumes: mosquitto_data:Vorteil: Einfach, direkt sichtbar. Nachteil: Nicht ideal für geheime Schlüssel oder wenn sich Werte häufig ändern. Erfordert Änderung am YAML.
-
Mit
.envDateien (für flexible und sensible Werte): Dies ist die beste Methode für umgebungsabhängige Werte. Du erstellst eine Datei namens.env(oderproduction.env,development.envetc.) im selben Verzeichnis wie deinedocker-compose.yml.my_project/.env:MQTT_BROKER_HOST=mosquitto KUKA_ROBOT_IP=192.168.1.101 KUKA_ROBOT_PORT=54321 VITE_MQTT_BROKER_HOST=mosquitto VITE_MQTT_BROKER_PORT=1883 # ... weitere IPs oder Portsmy_project/docker-compose.yml(Nutzt die Variablen aus.env):version: "3.9" services: mosquitto: image: eclipse-mosquitto:latest ports: - "1883:1883" volumes: - mosquitto_data:/mosquitto/data - ./mosquitto_config:/mosquitto/config robot_adapter_kuka: build: ./robot_adapter_kuka depends_on: - mosquitto env_file: # Docker Compose lädt diese Variablen automatisch aus der .env-Datei - .env networks: - iot-network dashboard: build: ./react-dashboard ports: - "3000:80" depends_on: - mosquitto env_file: - .env networks: - iot-network networks: iot-network: driver: bridge volumes: mosquitto_data:Vorteil: Du kannst die
.envDatei einfach auf dem Raspberry Pi anpassen, ohne diedocker-compose.ymlzu ändern..envDateien werden üblicherweise nicht in die Versionskontrolle aufgenommen (oder nur als.env.template). Nachteil: Erfordert, dass die.env-Datei auf dem Zielsystem existiert und korrekt konfiguriert ist.
b) Volumes für Konfigurationsdateien
Manche Anwendungen (wie Mosquitto, Nginx) bevorzugen Konfigurationen in Dateien. Du kannst diese Dateien als Volumes in deine Container mounten.
-
Beispiel Mosquitto: Um Mosquitto auf die Port 1883 zu konfigurieren oder eine ACL (Access Control List) zu definieren, brauchst du eine
mosquitto.conf.my_project/mosquitto_config/mosquitto.conf:persistence true persistence_location /mosquitto/data/ log_dest file /mosquitto/log/mosquitto.log allow_anonymous true # Für ein privates Labornetzwerk akzeptabel, sonst 'false' setzen! listener 1883my_project/docker-compose.yml:services: mosquitto: image: eclipse-mosquitto:latest ports: - "1883:1883" volumes: - mosquitto_data:/mosquitto/data - ./mosquitto_config:/mosquitto/config # Dies mountet den lokalen Ordner # ...Vorteil: Anwendungsspezifische Konfigurationen können leicht angepasst werden, ohne das Docker Image neu bauen zu müssen.
c) Netzwerk-Konfiguration (Innerhalb von Docker Compose)
Docker Compose erstellt ein internes Netzwerk, in dem die Services sich gegenseitig über ihre Servicenamen (z.B.
mosquitto) erreichen können. Die Port-Mappings (z.B.3000:80für das Dashboard) sorgen dafür, dass die Ports des Containers auf dem Host-System (Raspberry Pi) erreichbar sind.- Die IP-Adresse des Raspberry Pis selbst ist hier nur für den externen Zugriff auf das Dashboard (z.B. über
http://<RASPI_IP>:3000) relevant, nicht für die interne Kommunikation der Container.
2. Skripte mit systemd
Wenn du Docker nicht verwenden möchtest, manage Konfigurationen direkt auf dem Host-System.
a) Umgebungsvariablen in systemd Unit-Dateien
Du kannst Umgebungsvariablen direkt in deinen
.service-Dateien definieren oder aus einer Datei laden lassen.-
Direkt in der Unit-Datei:
# /etc/systemd/system/kuka_adapter.service [Unit] Description=KUKA LBR iiwa 14 Adapter [Service] WorkingDirectory=/home/pi/robot_adapter_kuka ExecStart=/usr/bin/python3 /home/pi/robot_adapter_kuka/kuka_adapter.py Environment="MQTT_BROKER_HOST=127.0.0.1" Environment="KUKA_ROBOT_IP=192.168.1.101" Environment="KUKA_ROBOT_PORT=54321" Restart=on-failure User=pi [Install] WantedBy=multi-user.targetVorteil: Alle Einstellungen direkt in der Service-Definition. Nachteil: Bei Änderungen muss die Unit-Datei editiert und
systemctl daemon-reload+systemctl restartausgeführt werden. -
Aus einer Umgebungsvariablen-Datei (
EnvironmentFile): Dies ist flexibler, da du die Datei bearbeiten kannst, ohne die.service-Datei anzufassen./etc/robot_configs/kuka_adapter.env:MQTT_BROKER_HOST=127.0.0.1 KUKA_ROBOT_IP=192.168.1.101 KUKA_ROBOT_PORT=54321/etc/systemd/system/kuka_adapter.service:[Unit] Description=KUKA LBR iiwa 14 Adapter [Service] WorkingDirectory=/home/pi/robot_adapter_kuka ExecStart=/usr/bin/python3 /home/pi/robot_adapter_kuka/kuka_adapter.py EnvironmentFile=/etc/robot_configs/kuka_adapter.env # Hier wird die Datei geladen Restart=on-failure User=pi [Install] WantedBy=multi-user.targetVorteil: Trennung von Service-Definition und Konfiguration. Einfacher für Nicht-Admins zu bearbeiten.
b) Konfigurationsdateien (Anwendungsspezifisch)
Python-Adapter oder das React-Dashboard können Konfigurationsdateien im jeweiligen Projektordner nutzen, die von den Skripten gelesen werden.
-
Beispiel Python Adapter (
config.pyoder.ini/.json):# kuka_adapter/config.py MQTT_BROKER_HOST = "127.0.0.1" # Kann von Umgebungsvariable überschrieben werden KUKA_ROBOT_IP = "192.168.1.101" KUKA_ROBOT_PORT = 54321Dein Python-Skript würde dann diese Datei importieren oder parsen. Es ist gute Praxis, dass Umgebungsvariablen Vorrang vor Dateikonfigurationen haben.
-
Beispiel React Dashboard: Hier ist es tricky, da React-Apps zur Build-Zeit gebundelt werden. Umgebungsvariablen müssen während des Builds zur Verfügung stehen (z.B. über Vite's
VITE_Präfix). Wenn du Nginx als Server nutzt, kann Nginx auch selbst Umgebungsvariablen oder dynamische Konfigurationen über Skripte nutzen, aber das geht über einfache statische React-Builds hinaus. Am einfachsten ist es, wenn die React-App einen MQTT-Host verwendet, der über das Docker Compose Netzwerk erreichbar ist (siehe oben).
3. Ansible (Für die Bereitstellung der Konfiguration)
Ansible ist nicht für die Laufzeit-Konfiguration zuständig, sondern dafür, wie die initiale Konfiguration auf den Raspberry Pi gelangt und aktualisiert wird.
a) Templating mit Jinja2
Ansible kann Konfigurationsdateien oder
.envDateien dynamisch generieren.-
Host-Variablen:
inventory/hosts.ini:[raspberry_pi] 192.168.1.10 raspi_prod # Name des Hosts [raspberry_pi:vars] mqtt_broker_ip="192.168.1.10" # IP des Raspi selbst für den Broker kuka_robot_ip="192.168.1.101" mitsubishi_robot_ip="192.168.1.102" -
Template-Datei (
templates/kuka_adapter.env.j2):MQTT_BROKER_HOST={{ mqtt_broker_ip }} KUKA_ROBOT_IP={{ kuka_robot_ip }} KUKA_ROBOT_PORT=54321 -
Ansible Playbook Task:
- name: Deploy KUKA adapter environment file template: src: templates/kuka_adapter.env.j2 dest: /home/pi/robot_adapter_kuka/.env # Für systemd # ODER # dest: /home/pi/my_project/.env # Für Docker Compose notify: restart kuka_adapter_service # oder restart docker composeVorteil: Vollständige Automatisierung. Du definierst die Variablen einmal im Ansible-Inventar oder in Playbooks, und Ansible generiert die korrekten Konfigurationsdateien für jeden spezifischen Raspberry Pi. Ideal, wenn du mehrere Raspberries hast oder Konfigurationen versionieren möchtest.
Zusammenfassung und Empfehlung:
-
Für Docker Compose (Highly Recommended):
- Nutze
.envDateien für die umgebungsabhängigen Variablen (IPs, Ports). Diese Datei wird manuell oder via Ansible/SCP auf den Pi kopiert und ist nicht im Git-Repo. - Nutze
volumesfür anwendungsspezifische Konfigurationsdateien (z.B.mosquitto.conf), die ebenfalls auf dem Pi liegen. - Interne Docker-Kommunikation erfolgt über Servicenamen (z.B.
mosquitto), die Auflösung der IP-Adresse der physischen Roboter geschieht über die in den Adaptern gesetzten Umgebungsvariablen.
- Nutze
-
Für systemd + Skripte:
- Nutze
EnvironmentFilein deinen systemd Unit-Dateien, um Variablen aus einer separaten Konfigurationsdatei zu laden. - Diese Konfigurationsdateien liegen direkt auf dem Raspberry Pi und können bei Bedarf angepasst werden.
- Nutze
GitLab CI/CD Integration:
Unabhängig von der gewählten Deployment-Methode kannst du GitLab CI/CD nutzen, um:
- Docker-Images zu bauen und in die GitLab Container Registry zu pushen.
- Die
docker-compose.yml(oder systemd Unit-Dateien und Skripte) auf den Raspberry Pi zu kopieren (z.B. via SCP oder rsync). - Ein
docker-compose pullunddocker-compose up -d(odersystemctl daemon-reloadundsystemctl restart) auf dem Raspberry Pi auszulösen.
- Wichtig: Füge keine sensitiven oder umgebungsabhängigen IPs/Ports direkt in dein Git-Repository hinzu! Verwende
.env.templateals Vorlage und fülle die tatsächliche.envDatei auf dem Pi manuell oder automatisiert (z.B. via Ansible Vault für sensible Daten) aus.
Durch diese Externalisierung der Konfiguration wird dein System extrem flexibel, einfach zu warten und zu aktualisieren.
-
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.