+
https://kb.shelly.cloud/knowledge-base/shelly-plus-1pm-web-interface-guide
+192.168.33.1
+Id: A8032AB82968
+bedroom: shellyplus1pm-a8032ab82968 → 192.168.178.53
+top child room: shellyplus1pm-a8032abba0b0 → 192.168.178.54
+living room: shellyplusi4-a8032ab1d7d0 → 192.168.178.55
+bed room: shellyplusi4-a8032ab1c9e0 → 192.168.178.56
+shellyrgbw2-E0AC83 → 192.168.178.76
+
FRITZ!Box 7530 GD
+78302839617779115068
+
MQTT credentials:
+192.168.178.32:1883 → 192.168.178.52:1883
+note4
+note4
+
https://shelly-api-docs.shelly.cloud/gen2/General/RPCChannels
+shellyplus1pm-a8032ab82968/rpc
+shellyplus1pm-a8032ab82968/events/rpc
+shellyplusi4-a8032ab1d7d0/events/rpc
+shellyplusi4-a8032ab1c9e0/events/rpc
+shellyrgbw2-E0AC83/events/rpc
+
https://www.home-assistant.io/integrations/shelly/
+Generation 2 devices use the values btn_down, btn_up, single_push, double_push and long_push as click_type.
+
http://192.168.178.53/rpc/Shelly.GetStatus
+
power consumption LED (green channel stuck at 100%; red LEDs not connected on one strip; in total ca. 250 LEDs):
+green 100%: 7.7 W
+green+blue 100%: 16.3 W
+green+red 100%: 18.7 W
+white = green+blue+red 100%: 26.4 W
+green 100%+blue 50%+red 50%: 17.8 W
+green 100%+blue 1%+red 1%: 9.7 W
+
nice automations:
+https://community.home-assistant.io/t/shelly-plus-i4-wall-switch-example-automation/401625
+
example to send command to shell:
+service: mqtt.publish
+data:
+topic: homeassistant/shellyplus1pm-fgfloodlights/rpc
+payload: >-
+{{ {‘id’: 1, ‘src’:‘homeassistant/shellyplus1pm-fgfloodlights/status’,
‘method’:‘Shelly.GetStatus’} | to_json }}
+
https://shelly-api-docs.shelly.cloud/gen2/ComponentsAndServices/Mqtt
+<model> = shellyplus1pm
+
https://shelly-api-docs.shelly.cloud/gen1/#shelly1-1pm-mqtt
+Shelly1/1PM: MQTT
+
Shelly1 and Shelly1PM uses the following topics, where <model> is either shelly1 or shelly1pm:
+
shellies/<model>-<deviceid>/relay/0 to report status: on, off or overpower (the latter only for Shelly1PM)
+shellies/<model>-<deviceid>/relay/0/command accepts on, off or toggle and applies accordingly
+shellies/<model>-<deviceid>/input/0 reports the state of the SW terminal
+shellies/<model>-<deviceid>/longpush/0 reports longpush state as 0 (shortpush) or 1 (longpush)
+shellies/<model>-<deviceid>/input_event/0 reports input event and event counter, e.g.: {"event":"S","event_cnt":2} see /status for details
+
Shelly1PM adds:
+
shellies/shelly1pm-<deviceid>/relay/0/power reports instantaneous power in Watts
+shellies/shelly1pm-<deviceid>/relay/0/energy reports an incrementing energy counter in Watt-minute
+shellies/shelly1pm-<deviceid>/temperature reports internal device temperature in °C
+shellies/shelly1pm-<deviceid>/temperature_f reports internal device temperature in °F
+shellies/shelly1pm-<deviceid>/overtemperature reports 1 when device has overheated, normally 0
+shellies/shelly1pm-<deviceid>/temperature_status reports Normal, High, Very High
+shellies/shelly1pm-<deviceid>/relay/0/overpower_value reports the value in Watts, on which an overpower condition is detected
+
https://community.home-assistant.io/t/shelly-gen-2-plus-and-pro-using-mqtt/347979/19
+mqtt:
+switch:
+- name: "Garage: Heat pump switch"
+state_topic: "garage-heat-pump-switch-pm/status/switch:0"
+value_template: "{{ value_json.output }}"
+state_on: true
+state_off: false
+command_topic: "garage-heat-pump-switch-pm/rpc"
+payload_on: '{"id":1, "src": "homeassistant", "method": "Switch.Set", "params":{"id":0,"on":true}}'
+payload_off: '{"id":1, "src": "homeassistant", "method": "Switch.Set", "params":{"id":0,"on":false}}'
+optimistic: false
+qos: 1
+retain: false
+sensor:
+- name: "Garage: Heat pump switch temperature"
+unique_id: 4ca71dd5-645d-48e5-a387-a655cc7dd42e
+state_topic: "garage-heat-pump-switch-pm/status/switch:0"
+value_template: "{{ value_json.temperature.tC }}"
+unit_of_measurement: "°C"
+device_class: temperature
++
- name: "Garage: Heat pump switch current power"
+unique_id: 44f6d6de-be45-4697-8ff9-882fae91c6a2
+state_topic: "garage-heat-pump-switch-pm/status/switch:0"
+value_template: "{{ value_json.apower }}"
+unit_of_measurement: "W"
+device_class: power
++
- name: "Garage: Heat pump switch total power"
+unique_id: 44f6d6de-be45-4697-8ff9-882fae91c6a1
+state_topic: "garage-heat-pump-switch-pm/status/switch:0"
+value_template: "{{ value_json.aenergy.total }}"
+unit_of_measurement: "W"
+device_class: power
+
https://community.openhab.org/t/shelly-plus-1pm-via-mqtt/139826
+Hi folkes,
I am a bit inpatient and cannot waiting for the Shelly binding to cover the new devices and I read that due to the new ESP32 and new API, Shelly devices can now run cloud and MQTT in parallel. So if you start controlling your new devices (e.g. the Shelly Plus 1PM) via MQTT, you are not missing out on anything else. So here is my thing code for the Shelly Plus 1PM:
UID: mqtt:topic:5d0f79cab1:b0df524d88
https://sequr.be/blog/2020/10/mqtt-templates-for-shelly-devices/#mqtt-templates
+## /sensors/room_x/lamp.yaml
+
# Input type
+- platform: mqtt
+name: Room X - lamp - input
+expire_after: 86400
+qos: 1
+state_topic: shellies/shelly1pm-[SHELLY ID]/input_event/0
+# Device temperature °C
+- platform: mqtt
+name: Room X - lamp - temperature
+expire_after: 86400
+qos: 1
+device_class: temperature
+unit_of_measurement: '°C'
+icon: mdi:temperature-celcius
+state_topic: shellies/shelly1pm-[SHELLY ID]/temperature
+# Device temperature °F
+- platform: mqtt
+name: Room X - lamp - temperature F
+expire_after: 86400
+qos: 1
+device_class: temperature
+unit_of_measurement: '°F'
+icon: mdi:temperature-fahrenheit
+state_topic: shellies/shelly1pm-[SHELLY ID]/temperature_f
+# Power consumption (live)
+- platform: mqtt
+name: Room X - lamp - power
+expire_after: 86400
+qos: 1
+device_class: power
+unit_of_measurement: 'W'
+icon: mdi:lightning-bolt-outline
+state_topic: shellies/shelly1pm-[SHELLY ID]/relay/0/power
+# Power consumption (since reboot)
+- platform: mqtt
+name: Room X - lamp - energy
+expire_after: 86400
+qos: 1
+device_class: energy
+state_class: total_increasing
+unit_of_measurement: 'Wh'
+value_template: "{{ value | float / 60 }}"
+icon: mdi:lightning-bolt
+state_topic: shellies/shelly1pm-[SHELLY ID]/relay/0/energy
+# Overpower
+- platform: mqtt
+name: Room X - lamp - overpower
+expire_after: 86400
+qos: 1
+device_class: power
+unit_of_measurement: 'W'
+icon: mdi:flash-alert
+state_topic: shellies/shelly1pm-[SHELLY ID]/overpower_value
+
https://usa.shelly.cloud/knowledge-base/shelly-rgbw2/
+https://community.home-assistant.io/t/shelly-rgbw2-automations-mqtt/234564
+ +shellies/shellyrgbw2-E0AC83/white/3/status
+shellies/shellyrgbw2-E0AC83/color/0/status
+
https://www.esphome-devices.com/devices/Shelly-Plus-1PM
+
https://community.home-assistant.io/t/shelly-firmware-updates/123123/2
+in configuration.yaml, add the rest integration and configure like so:
+
rest_command:
+update_shelly:
+url: 'http://{{ shelly_ip }}/ota?update=true'
+
create a new automation, eg. shellyupdate.yaml that looks like this:
+
- alias: "Shelly New Firmware Notification"
+id: 'snfn'
+trigger:
+platform: mqtt
+topic: shellies/announce
+condition:
+condition: template
+value_template: "{{ trigger.payload_json['new_fw'] == true }}"
+action:
+- service: persistent_notification.create
+data_template:
+title: "New Shelly Firmware Update Released. Update will be attempted."
+message: Update will be attempted"
+notification_id: "{{ trigger.payload_json['id'] }}"
+- service: rest_command.update_shelly
+data:
+shelly_ip: "{{ trigger.payload_json['ip'] }}"
++
- alias: "Shelly New Firmware Notification Removal"
+id: 'snfnr'
+trigger:
+platform: mqtt
+topic: shellies/announce
+condition:
+condition: template
+value_template: "{{ trigger.payload_json['new_fw'] == false }}"
+action:
+service: persistent_notification.dismiss
+data_template:
+notification_id: "{{ trigger.payload_json['id'] }}"
+
http://[IP-OF-SHELLY/ota?update=1 does the trick
+
https://smarthome.university/home-assistant/node-red/
+
https://funprojects.blog/2020/03/23/home-assistant-with-node-red/
+
Solarman?
+See KeePassXC
+
https://www.wemos.cc/en/latest/c3/c3_mini.html
+
https://www.fambach.net/d1-mini-esp8266-modul-2-3/
+static const uint8_t LED_BUILTIN = 7;
+#define BUILTIN_LED LED_BUILTIN // backward compatibility
+static const uint8_t TX = 21;
+static const uint8_t RX = 20;
+static const uint8_t SDA = 8;
+static const uint8_t SCL = 10;
+static const uint8_t SS = 5;
+static const uint8_t MOSI = 4;
+static const uint8_t MISO = 3;
+static const uint8_t SCK = 2;
+static const uint8_t A0 = 0;
+static const uint8_t A1 = 1;
+static const uint8_t A2 = 2;
+static const uint8_t A3 = 3;
+static const uint8_t A4 = 4;
+static const uint8_t A5 = 5;
+
Wifi funktioniert nicht → Wifi TX auf 8,5 dBm setzen:
+WiFi.setTxPower(WIFI_POWER_8_5dBm);
+
Configure Board
+Use lastest esp32 arduino package
+Choose board LOLIN C3 MINI
+Upload Code
+Make C3 boards into Device Firmware Upgrade (DFU) mode.
+Hold on Button 9
+Press Button Reset
+Release Button 9 When you hear the prompt tone on usb reconnection
+
D:\”Home Assistant”\Python\myenv\Scripts\activate.bat
+pip install esptool
+
Make S2 boards into Device Firmware Upgrade (DFU) mode.
++
Hold on Button 0
+Press Button Reset
+Release Button 0 When you hear the prompt tone on usb reconnection
+Flash using esptool.py
+esptool.py --port PORT_NAME erase_flash
+esptool.py --port COM20 erase_flash
+esptool.py --port PORT_NAME --baud 1000000 write_flash -z 0x1000 FIRMWARE.bin
+esptool.py --port PORT_NAME --baud 1000000 write_flash -z 0x1000 FIRMWARE.bin
+
https://codeandlife.com/2022/02/25/using-ssd1306-oled-wemos-s2-pico-esp32-s2-board/
+
https://microcontrollerslab.com/oled-display-raspberry-pi-pico-micropython-tutorial/
+We will have to install the SSD1306 OLED library for MicroPython to continue with our project.
+To successfully do that, open your Thonny IDE with your Raspberry Pi Pico plugged in your system. Go to Tools > Manage Packages. This will open up the Thonny Package Manager.
+
Search for “ssd1306” in the search bar by typing its name and clicking the button ‘Search on PyPI.’
+
From the following search results click on the one highlighted below: micropython-ssd1306
+
Install this library.
+
https://github.com/slashback100/presence_simulation
+
https://blog.jonsdocs.org.uk/2022/08/29/simulating-presence-with-home-assistant/
+
I created an toggle helper called input_boolean.holidaymode:
Go to Settings then Devices & Services
+Click on the Helpers tab (in the web interace this will be at the top, on the Android app it's an icon at the bottom
+Click create helper
+Choose Toggle
+Type a name (e.g., HolidayMode) and choose an icon (e.g., mdi:beach) and click Create
The list of helpers will now include input_boolean.holidaymode
As the automation stores the light it is going to change (switch on or off) in the "light to switch" variable, we need to create that.
+Go to Settings then Devices & Services
+Click on the Helpers tab (in the web interace this will be at the top, on the Android app it's an icon at the bottom
+Click create helper
+Choose Text
+For name, type light_to_switch and leave the other options as their defaults
Click Create
+The list of helpers will now include input_text.light_to_switch
Once we've created the light group we'll be referencing it by name in the automation.
+Go to Settings then Devices & Services
+Click on the Helpers tab (in the web interace this will be at the top, on the Android app it's an icon at the bottom
+Click create helper
+Choose Group (a circle with three dots in it)
+When asked what type of group this is, choose Light group
+Give your group a name (e.g., "Presence simulation lights") and choose the members to include in the group
+Click Submit
+In the helpers list you'll see a group called light.presence_simulation_lights - copy this name exactly as we'll need it in the automation
Create automation - random lights on
+alias: "Holiday mode: Presence simulation"
+
+trigger:
+
+ - platform: time_pattern
+
+ minutes: /30
+
+condition:
+
+ - condition: state
+
+ entity_id: input_boolean.holidaymode
+
+ state: "on"
+
+ - condition: sun
+
+ after: sunset
+
+ after_offset: "-00:30:00"
+
+ - condition: time
+
+ before: "22:00:00"
+
+action:
+
+ - delay: 00:{{ '{:02}'.format(range(0,30) | random | int) }}:00
+
+ - service: input_text.set_value
+
+ data_template:
+
+ entity_id: input_text.light_to_switch
+
+ value: "{{ state_attr('light.presence_simulation_lights','entity_id') | random }}"
+
+ - service: homeassistant.toggle
+
+ data_template:
+
+ entity_id: "{{states('input_text.light_to_switch')}}"
+
+initial_state: true
+
+hide_entity: false
Create automation - lights off at random bedtime
+alias: "Holiday mode: Turning off all toggled lights"
+
+description: ""
+
+trigger:
+
+ - platform: time
+
+ at: "23:00:00"
+
+condition:
+
+ - condition: state
+
+ entity_id: input_boolean.holidaymode
+
+ state: "on"
+
+action:
+
+ - delay: 00:{{ range(15,59) | random | int }}:00
+
+ - service: homeassistant.turn_off
+
+ data: {}
+
+ target:
+
+ entity_id: light.presence_simulation_lights
+
+initial_state: true
+
+hide_entity: false
+
+mode: single
https://blog.mornati.net/home-assistant-simple-presence-simulation-script
+
Add the following script in your scripts configuration file (ie scripts.yaml)
COPY
+light_duration:
+
+ mode: parallel
+
+ description: "Turns on a light for a while, and then turns it off"
+
+ fields:
+
+ light:
+
+ description: "A specific light"
+
+ example: "light.bedroom"
+
+ duration:
+
+ description: "How long the light should be on in minutes"
+
+ example: "25"
+
+ sequence:
+
+ - service: homeassistant.turn_on
+
+ data:
+
+ entity_id: "{{ light }}"
+
+ - delay: "{{ duration }}"
+
+ - service: homeassistant.turn_off
+
+ data:
+
+ entity_id: "{{ light }}"
The automation will then start the script providing the correct parameters.
+COPY
+- id: random_away_lights
+
+ alias: "Random Away Lights"
+
+ mode: parallel
+
+ trigger:
+
+ - platform: time_pattern
+
+ minutes: "/30"
+
+ condition:
+
+ - condition: state
+
+ entity_id: input_boolean.away
+
+ state: "on"
+
+ - condition: sun
+
+ after: sunset
+
+ after_offset: "-00:30:00"
+
+ - condition: time
+
+ before: "23:59:00"
+
+ action:
+
+ service: script.light_duration
+
+ data:
+
+ light: "{{states.group.simulation_lights.attributes.entity_id | random}}"
+
+ duration: "00:{{ '{:02}'.format(range(5,30) | random | int) }}:00"
I created a group with a list of lights I want to use to simulate the presence. I put only the lights within the rooms visible from the outside.
+COPY
+simulation_lights:
+
+ name: Lights Presence Simulation
+
+ entities:
+
+ - light.salle_manger
+
+ - light.cuisine_table
+
+ - light.bureau_marco
+
+ - light.salon_corner
https://github.com/nielsfaber/scheduler-component
+https://github.com/nielsfaber/scheduler-card
+
https://www.home-assistant.io/integrations/recorder
+recorder:
+purge_keep_days: 5
+db_url: sqlite:////home/user/.homeassistant/test
+
https://community.home-assistant.io/t/simple-way-to-reduce-your-db-size/234787
+open up a terminal (SSH or via web, I use this extension for this purpose https://github.com/hassio-addons/addon-ssh 130)
+change directory to config cd ~/config
open sqlite shell sqlite3 home-assistant_v2.db
enter the following commands in the shell:.header on.mode column.width 50, 10,SELECT entity_id, COUNT(*) as count FROM states GROUP BY entity_id ORDER BY count DESC LIMIT 20;
https://community.home-assistant.io/t/how-to-keep-your-recorder-database-size-under-control/295795
+homeassistant:
+allowlist_external_dirs:
+- /config
+sensor:
+- platform: filesize
+file_paths:
+- /config/home-assistant_v2.db
+
SCENES = {
+1: "Ocean",
+2: "Romance",
+3: "Sunset",
+4: "Party",
+5: "Fireplace",
+6: "Cozy",
+7: "Forest",
+8: "Pastel Colors",
+9: "Wake up",
+10: "Bedtime",
+11: "Warm White",
+12: "Daylight",
+13: "Cool white",
+14: "Night light",
+15: "Focus",
+16: "Relax",
+17: "True colors",
+18: "TV time",
+19: "Plantgrowth",
+20: "Spring",
+21: "Summer",
+22: "Fall",
+23: "Deepdive",
+24: "Jungle",
+25: "Mojito",
+26: "Club",
+27: "Christmas",
+28: "Halloween",
+29: "Candlelight",
+30: "Golden white",
+31: "Pulse",
+32: "Steampunk",
+1000: "Rhythm",
+}
+
https://iotprojectsideas.com/portable-esp32-wifi-repeater/
+
download repository and flash tool:
+https://github.com/martin-ger/esp32_nat_router
+https://www.espressif.com/en/support/download/other-tools
+
run the tool and select the three files in the folder D:\Home Assistant\ESP32_wifi_repeater\esp32_nat_router-master\build\esp32: bootloader.bin, firmware.bin, partitions.bin
+
Now, we also need to specify the hex code indicating where the files are. For the bootloader type 0x1000, for esp32 nat router file type 0x10000, and for partition file type 0x8000.
+
Press and hold the boot button on your ESP32 board and click on the start button to start flashing firmware.
+
After the first boot, it provides an open WiFi SSID “ESP32_NAT_Router“. Connect to this WiFi network and perform basic configuration via a simple web interface.
+
The web interface allows for the configuration of all the parameters required for basic forwarding functionality. Open your web browser and enter the following address: “http://192.168.4.1“. Now you should see the following page.
+
Firstly, in the “STA Settings” enter the correct WiFi credentials of your main WiFi network that you want to extend. Leave the password field for open networks. Click on “Connect“. The ESP32 reboots and will connect to your WiFi router. You should see the status LED ON after a few seconds.
+
You can now reload the page and change the “AP Settings“. Enter New SSID and Password and click “Set” and again the ESP reboots. Now it is ready for forwarding traffic over the newly configured Access Point.
+
SSID: ESP32_NAT_Router
+pass: mysupersecurepassword
+
192.168.178.52
+pi
+raspberry
+
https://raspberrytips.com/docker-on-raspberry-pi/
+sudo apt update
+sudo apt upgrade -y
+sudo reboot
+curl -sSL https://get.docker.com | sh
+Allow Docker to be used without being a root → So, here is the command to add the current user to the docker group: sudo usermod -aG docker $USER → sudo usermod -aG docker pi
+Exit your SSH session, or restart the Raspberry Pi, and you should then be able to run any docker command without sudo. → docker ps → If it works, you are ready to move forward.
+Test your Docker setup: docker run hello-world
+
Monitor the running containers:
+docker ps
+Display the current version of Docker:
+docker version
+Download a new image:
+docker pull [IMAGE]
+Run an image (and download it if not existing on your local system):
+docker run [IMAGE]
+Search for an image in the Docker repository:
+docker search [X]
+Show the usage statistics:
+docker stats
+Display the list of all the Docker commands:
+docker help
+
https://www.home-assistant.io/installation/raspberrypi#install-home-assistant-container
+docker run -d \
+--name homeassistant \
+--privileged \
+--restart=unless-stopped \
+-e TZ=Europe/Berlin \
+-v /PATH_TO_YOUR_CONFIG:/config \
+--network=host \
+ghcr.io/home-assistant/home-assistant:stable
+
Once the Home Assistant Container is running Home Assistant should be accessible using http://<host>:8123
+http://192.168.178.52:8123
+
RESTART HOME ASSISTANT
+docker restart homeassistant
+
https://community.home-assistant.io/t/configurator-file-editor-for-ha-core-in-docker/238472/4
+cd ~/docker
+mkdir configurator
+cd configurator
+sudo nano docker-compose.yaml
+
version: "3.5"
+services:
+configurator:
+container_name: configurator
+image: causticlab/hass-configurator-docker:latest
+restart: always
+network_mode: host
+labels:
+- "com.centurylinklabs.watchtower.enable=true" # for Watchtower automatic updates
+ports:
+- "3218:3218/tcp"
+volumes:
+- ${HASSIODIR}/:/config # map this volume to your hassio config directory
+environment:
+- HC_BASEPATH=/config
+- HC_HASS_API_PASSWORD=${CONFIGURATORPSWD} #Create a Long-Lived Access Token
+- HC_IGNORE_SSL=True
+- PUID=${PUID}
+- PGID=${PGID}
+- TZ=${TZ}'
+
docker-compose up -d
+
http://192.168.178.52:3218
+
https://community.home-assistant.io/t/configure-ssl-with-docker/196878
+edit configuration.yaml:
+http:
+base_url: https://myhomeassistant.com:8123
+ssl_certificate: /config/fullchain.pem
+ssl_key: /config/privkey.pem
+
create certifactes:
+cd /PATH_TO_YOUR_CONFIG
+sudo openssl req -sha256 -addext "subjectAltName = IP:192.168.178.52" -newkey rsa:4096 -nodes -keyout privkey.pem -x509 -days 730 -out fullchain.pem
+
Home Assistant in Docker with Nginx and Let's Encrypt on Raspberry Pi
+
cd ~/docker
+mkdir proxy
+cd proxy
+sudo nano docker-compose.yaml
+
version: '3'
+services:
+nginx:
+image: arm64v8/nginx
+ports:
+- "80:80"
+volumes:
+- ./data/nginx:/etc/nginx/conf.d:ro
+- ./data/wwwroot:/var/www/root:ro
+
mkdir data
+cd data
+mkdir nginx
+cd nginx
+sudo nano app.conf
+
server {
+listen 80;
+server_name habora.duckdns.org; #replace this
+location / {
+root /var/www/root;
+}
+}
+
cd ..
+mkdir wwwroot
+cd wwwroot
+sudo nano index.html
+
<html>
+<body>
+<h1>Welcome</h1>
+It works!
+</html>T
+
cd ~/docker/proxy
+docker-compose up -d
+
http://192.168.178.52:80/
+
cd ~/docker/proxy
+sudo nano docker-compose.yaml
+
version: '3'
+services:
+nginx:
+image: arm64v8/nginx
+ports:
+- "80:80"
+- "443:443" # added
+volumes:
+- ./data/nginx:/etc/nginx/conf.d:ro
+- ./data/wwwroot:/var/www/root:ro
+- ./data/certbot/conf:/etc/letsencrypt:ro # added
+- ./data/certbot/www:/var/www/certbot:ro # added
+
certbot: # added
+image: certbot/certbot:arm64v8-latest # added
+volumes: # added
+- ./data/certbot/conf:/etc/letsencrypt # added
+- ./data/certbot/www:/var/www/certbot # added
+
cd ~/docker/proxy/data/nginx
+sudo nano app.conf
+
server {
+listen 80;
+server_name habora.duckdns.org; # replace this
+location /.well-known/acme-challenge/ { # added
+root /var/www/certbot; # added
+} # added
+location / {
+root /var/www/root;
+}
+}
+server {
+listen 443 ssl;
+server_name habora.duckdns.org;
+
location / {
+root /var/www/root;
+}
+
ssl_certificate /etc/letsencrypt/live/habora.duckdns.org/fullchain.pem;
+ssl_certificate_key /etc/letsencrypt/live/habora.duckdns.org/privkey.pem;
++
#Optional: Only works with Philipp's script (see below)
+include /etc/letsencrypt/options-ssl-nginx.conf;
+ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;
+}
+
cd ~/docker/proxy
+curl -L https://raw.githubusercontent.com/wmnnd/nginx-certbot/master/init-letsencrypt.sh > init-letsencrypt.sh
+
sudo nano init-letsencrypt.sh
+Edit the script to add in your domain(s) and your email address. If you’ve changed the directories of the shared Docker volumes, make sure you also adjust the data_path variable as well.
+Email: boraers@googlemail.com, https://habora.duckdns.org
+
chmod +x init-letsencrypt.sh
+sudo ./init-letsencrypt.sh
+
docker-compose up -d
+http://habora.duckdns.org:80/
+
rm docker-compose.yaml
+sudo nano docker-compose.yaml
+
version: '3'
+services:
+nginx:
+image: arm64v8/nginx
+ports:
+- "80:80"
+- "443:443"
+volumes:
+- ./data/nginx:/etc/nginx/conf.d:ro
+- ./data/wwwroot:/var/www/root:ro
+- ./data/certbot/conf:/etc/letsencrypt:ro
+- ./data/certbot/www:/var/www/certbot:ro
+command: "/bin/sh -c 'while :; do sleep 6h & wait $${!}; nginx -s reload; done & nginx -g \"daemon off;\"'"
+certbot:
+image: certbot/certbot:arm64v8-latest
+volumes:
+- ./data/certbot/conf:/etc/letsencrypt
+- ./data/certbot/www:/var/www/certbot
+entrypoint: "/bin/sh -c 'trap exit TERM; while :; do certbot renew; sleep 12h & wait $${!}; done;'"
+
http://192.168.178.52:9000/
+
https://nginxproxymanager.com/guide/#quick-setup
+cd ~/docker/proxy
+sudo rm * -R
+sudo nano docker-compose.yml
+
version: '3'
+services:
+app:
+image: 'jc21/nginx-proxy-manager:latest'
+restart: unless-stopped
+ports:
+- '80:80'
+- '81:81'
+- '443:443'
+volumes:
+- ./data:/data
+- ./letsencrypt:/etc/letsencrypt
+
docker-compose up -d
+
https://theprivatesmarthome.com/how-to/set-up-nginx-proxy-manager-in-home-assistant/
+open the admin page:
+http://127.0.0.1:81
+http://192.168.178.52:81
+Email: admin@example.com
+Password: changeme
+
add prox host:
+domain names: habora.duckdns.org
+scheme: http
+forward hostname / ip: 192.168.178.52:8123
+forward port: 8123
+ache asset: false
+block common explots: true
+websockets support: true
+access list: publicl accessible
+SSL
+“request a new ssl certificate”
+force SSL: true
+ +
edit configuration.yaml
+http:
+use_x_forwarded_for: true
+trusted_proxies:
+- 172.16.0.0/12
+
these options work now ==>
+http://192.168.178.52:8123/lovelace/0
+https://habora.duckdns.org/lovelace/0
+
https://www.addictedtotech.net/nginx-proxy-manager-tutorial-duckdns-configuration-episode-7/
+
STEP 1: SET UP A DUCKDNS ACCOUNT.
+The First thing to do will be to set up a DuckDNS account which is easy.
+Just navigate to their homepage and log in using one of the many sign in options they offer. In our example we use Google.
+
+
https://www.duckdns.org
++
STEP 2: ENTER A DUCKDNS SUBDOMAIN.
+Once logged in we are going to create a subdomain by entering into the white box a name you would like to use for your service.
+Note: You will need to create a new subdomain for each docker container service you host.
+In our example, we just put in “a2t“. Then click on the green “add domain” button.
+
This now gives us a domain name to use. In our case it is a2t.duckdns.org.
+The DuckDNS service will automatically take the public IP address you are currently on and add this to the IP field. If you are using a VPN, proxy or are using any other network that is different from the one you want to host your service on you will need to update this IP manually to start with to ensure the correct IP address is used. (This will be auto-updated later by our DuckDNS container either way).
+STEP 3: CREATE AND DEPLOY THE DUCKDNS CONTAINER USING A STACK.
+Now we have our subdomain we are going to “log in” to our “Portainer” dashboard on our Raspberry Pi and navigate to the “Stacks” page:
++
http://192.168.2.5:9000/#!/1/docker/stacks
++
From there we are going click on the “Add stack” button.
+This will open up a new Stack creation window. We will then name our stack “duckdns“
+
Then in the Web editor we will paste the following Docker compose data into the empty field.
+DOCKER COMPOSE STACK:
++
---
++
version: "2.1"
+services:
+duckdns:
+image: ghcr.io/linuxserver/duckdns
+container_name: duckdns
+environment:
+- PUID=1000 #optional
+- PGID=1000 #optional
+- TZ=Europe/London
+- SUBDOMAINS=subdomain1,subdomain2
+- TOKEN=token
+- LOG_FILE=false #optional
+volumes:
+- /path/to/appdata/config:/config #optional
+restart: unless-stopped
+---
+version: "2.1"
+services:
+duckdns:
+image: ghcr.io/linuxserver/duckdns
+container_name: duckdns
+environment:
+#- PUID=1000 #optional
+#- PGID=1000 #optional
+- TZ= Europe/Berlin
+- SUBDOMAINS=habora #subdomain1,subdomain2
+- TOKEN=799093a4-0b34-454f-99cb-25a4637bf404
+- LOG_FILE=false #optional
+volumes:
+- /path/to/appdata/config:/config #optional
+restart: unless-stopped
+
You will then need to change the fields to match your installation. If you would like to use a specific user account then you will need to find the PUID and GUID of that user account. We have shown how to do this in our Youtube Video so please watch that. If you would like to go with the defaults just remove both these fields as they are optional.
+Set your timezone “TZ” to your current location.
+Add your subdomain name to the “SUBDOMAIN” field. If you have more than one you will need to add an entry for each subdomain you wish to use and separate them with a comma.
+Note you do not need to add the full domain name only the subdomain part. In our example, we would only put “a2t” into the “SUBDOMAIN” field. not a2t.duckdns.org.
+Add your Token to the TOKEN field, which can be found on the Duckdns subdomain creation page at the top right. This is unique to every user and only needs to be put in once regardless of how many subdomains you use.
+
If you would like to use logs then you can change the field to “true” this is optional.
+Under Volumes add the location of where you install all your Docker data.
+Now you have set them fields your Docker compose Stack should look something like this:
+
Now you have confirmed all is set up correctly you can press the “Deploy the stack” button.
+
You can now check the Portainer containers page to confirm the “duckdns” container has been created correctly.
+
Press the Logs button to check all is as expected. It should look like this:
+
To confirm your domain is working correctly you can open a browser window and enter your domain name into the address field.
++
http://a2t.duckdns.org
++
You should now see this:
+
https://www.schaerens.ch/raspi-setting-up-mosquitto-mqtt-broker-on-raspberry-pi-docker/
+Install Docker on Raspberry Pi
+curl -sSL https://get.docker.com | sh
+
Add user pi to group docker:
+sudo usermod -aG docker pi
+
Install Docker Compose (first install Python and Pip)
+sudo apt-get install libffi-dev libssl-dev python3-dev python3 python3-pip -y
+sudo pip3 install docker-compose
+
sudo reboot
+
Create the following directory tree
+sudo mkdir /docker
+sudo mkdir /docker/mosquitto
+sudo mkdir /docker/mosquitto/config
+
Create the config file for Mosquitto with the following content:
+sudo nano /docker/mosquitto/config/mosquitto.conf
+# Config file for mosquito
+listener 1883
+#protocol websockets
+persistence true
+persistence_location /mosquitto/data/
+log_dest file /mosquitto/log/mosquitto.log
+allow_anonymous false
+
Create the config file for docker-compose with the following content (pay attention to the indentation of the lines in the YAML file, use 4 spaces per indentation, no tabs):
+cd /docker
+sudo nano docker-compose.yaml
+
version: '3'
+
services:
+mosquitto:
+container_name: mosquitto
+restart: always
+image: eclipse-mosquitto
+ports:
+- "1883:1883"
+- "9001:9001"
+volumes:
+- ./mosquitto/config/mosquitto.conf:/mosquitto/config/mosquitto.conf
+- ./mosquitto/data:/mosquitto/data
+- ./mosquitto/log:/mosquitto/log
+networks:
+- default
+
networks:
+default:
+
version: "3"
+
services:
+mosquitto:
+image: eclipse-mosquitto
+network_mode: host
+volumes:
+- ./conf:/mosquitto/conf
+- ./data:/mosquitto/data
+- ./log:/mosquitto/log
+
sudo nano /docker/mosquitto/config/mosquitto.conf
+
## Config file for mosquito
+listener 1883
+#protocol websockets
+persistence true
+persistence_location /mosquitto/data/
+log_dest file /mosquitto/log/mosquitto.log
+#allow_anonymous false
+password_file /mosquitto/config/mosquitto.conf
+
docker-compose exec mosquitto mosquitto_passwd -c /mosquitto/config/mosquitto.passwd mosquitto
+
sudo apt install docker-compose
+pip3 install --upgrade requests
+
docker run -d -p 8080:80 --name webserver nginx
+docker rm mosquitto
+sudo docker run -d -it --name mosquitto -p 127.0.0.1:1883:1883 eclipse-mosquitto
+sudo docker run -d -it --name mosquitto -p 8001:8001 myserver_new
+https://community.openhab.org/t/mosquitto-error-address-already-in-use/121506
+
Now you can install and start Mosquitto:
+docker-compose up -d
+
Check if Mosquitto is running:
+docker ps
+
https://hub.docker.com/_/eclipse-mosquitto/
+docker pull eclipse-mosquitto
+
https://medium.com/himinds/mqtt-broker-with-secure-tls-and-docker-compose-708a6f483c92
+https://www.diyhobi.com/install-mqtt-and-openhab-3-in-docker-raspberry-pi-4/
+curl -sSL https://get.docker.com | sh
+sudo usermod -aG docker pi
+sudo apt-get install libffi-dev libssl-dev python3-dev python3 python3-pip -y
+sudo pip3 install docker-compose
+sudo reboot
+cd
+mkdir docker
+cd docker
+mkdir smarthome
+mkdir smarthome/mqtt
+mkdir smarthome/mqtt/config
+
sudo nano smarthome/mqtt/config/mosquitto.conf
+# Config file for mosquitto
+
listener 1883
+
persistence true
+
persistence_location /mosquitto/data/
+
log_dest file /mosquitto/log/mosquitto.log
+
allow_anonymous false
+
cd smarthome
+nano docker-compose.yaml
+
version: '3.5'
+
services:
+#mqtt
+mosquitto:
+container_name: mqtt
+#hostname: mosquitto
+restart: always
+image: eclipse-mosquitto
+ports:
+- "8883:8883"
+- "9001:9001"
+volumes:
+- ./mqtt/config/mosquitto.conf:/mosquitto/config/mosquitto.conf
+- ./mqtt/data:/mosquitto/data
+- ./mqtt/log:/mosquitto/log
+networks:
+- default
+
networks:
+default:
+
docker-compose up -d
+
docker ps
+cd ~/docker/smarthome
+sudo rm * -R
+
cd mqtt
+cd config
+ls
+sudo rm mosquitto.conf -R
+
sudo nano mosquitto.conf
+
# Config file for mosquitto
+
listener 1883
+
persistence true
+
persistence_location /mosquitto/data/
+
log_dest file /mosquitto/log/mosquitto.log
+
allow_anonymous false
+
cd ~/docker/smarthome
+
docker-compose up -d
+
docker exec -it mqtt sh
+mosquitto_passwd -c /mosquitto/data/pwfile mymqtt
+Username: mymqtt, Password: mypassword
+
exit
+
sudo nano ~/docker/smarthome/mqtt/config/mosquitto.conf
+Paste this at the bottom: password_file /mosquitto/data/pwfile
+
docker start mqtt
+docker ps
+
192.168.178.52:1883
+
https://darkwolfcave.de/raspberry-pi-docker-ohne-probleme-installieren/
+docker volume create portainer_data
+docker run -d -p 8000:8000 -p 9443:9443 --name portainer --restart=always -v /var/run/docker.sock:/var/run/docker.sock -v portainer_data:/data portainer/portainer-ce:latest
+docker ps
+
https://IP-DEINES-RASPBERRYS:9443 → https://192.168.178.52:9443
+user: admin, pass: password1234
+
sudo mkdir /opt/influxdb
+sudo mkdir /opt/grafana
+sudo chmod 775 /opt/influxdb/ /opt/grafana/
+
influxdb:1.8
+8086
+/var/lib/influxdb
+
grafana/grafana
+3000
+/var/lib/grafana (was leider nur auf der Grafana Seite direkt steht und nicht hier)
+
Starte, am besten in einem neuen Tab, deine Portainer-Umgebung (https://IP-DES_RASPBERRY:9443) und logge dich ein.
In der linken Menüseite wähle den Punkt „Containers“ und dann klicke auf den Button “ + Add container„:
Lass dich von den Einstellungen nicht erschlagen. Nicht alle benötigen wir, und alle anderen werden nach und nach klarer.
+
Als Erstes geben wir unserem Container einen Namen(1): influxDB
+Dann suchen wir das entsprechende Image (2) bei „DockerHub“ : influxdb:1.8
+Jetzt klickst du auf den Button publish a new network port(3) und trägst bei Host(4) und Container(5) jeweils den Port 8086 ein
+
Unter dem Punk „Command & logging“ solltest du für die Console „Interactive & TTY“ auswählen.
+
Etwas weiter unten klickst du jetzt auf „Volumes(1)„, dann auf „map additional volume(2)“ sowie auf den Button „Bind(3)„.
Du erinnerst dich noch an den Pfad, den wir auf der hub.docker Seite unter influxDB in der Beschreibung gesehen haben?
Denn diesen müssen wir jetzt bei „container(4)“ eintragen: /var/lib/influxdb.
Bei „Host(5)“ kommt jetzt das Gegenstück dazu rein, nämlich der Ordner, den wir für die persistenten Daten auf unserem Raspberry angelegt haben: /opt/influxdb
Im Reiter „Restart policy“ geben wir noch an, wie sich unser Container verhalten soll, falls der Raspberry mal neu startet oder der Container selbst sich mit einem Fehler beendet hat. Hier wählen wir „Always“ – er soll also immer wieder selbst neu starten.
+
Nun haben wir soweit alles angegeben was wir benötigen und können, wieder etwas weiter oben, auf den Button „Deploy the container“ klicken.
Das Ganze dauert dann ein wenig, da zu erst das Image heruntergeladen, entpackt und der Container entsprechend angelegt werden muss. Beim nächsten Deploy des Containers würde es deutlich schneller gehen:
Hiermit hast du jetzt influxDB erfolgreich als Container gestartet. Prüfen kannst du das natürlich auch. Im Menüpunkt Containers wirst du in der Übersicht einen neuen influxDB Container im Status running sehen. Schaue auch ruhig einmal in die Logs.
+
user:bora, pass:password1234, orga:home, bucket:influxdb_rapi4
+token_01: GK_kb2fTPaEknWQ7c9c5VRU5c5GeRXv8is3_e0qhn9qXLOdbxHkdAfqYZNrfn1jexfQ-RVKYtX7Co9HvKgIJqg==
+
https://diyi0t.com/visualize-mqtt-data-with-influxdb-and-grafana/
+
https://thenewstack.io/python-mqtt-tutorial-store-iot-metrics-with-influxdb/
+
https://darkwolfcave.de/raspberry-pi-monitoring-grafana-installieren/
+
(1) – Name des Containers: „Grafana„
+(2) – Name des Image: „grafana/grafana„
+(3) – Anklicken um neue Ports eingeben/binden zu können
+(4) – Port des Hosts(Raspberry): 3000
+(5) – Port des Containers: 3000
+(6) – Button „Volumes“ anklicken
+(7) – Den Button bei Volume mapping klicken damit wir die Pfade eingeben können
+(8) – Button „Bind“ anklicken
+(9) – Pfad des Containers: /var/lib/grafana
+(10) – Pfad auf dem Host(Raspberry) dazu: /opt/grafana
+Im Reiter „Restart policy“ geben wir jetzt noch an, wie sich unser Container verhalten soll, falls der Raspberry mal neu startet oder der Container selbst sich mit einem Fehler beendet hat. Hier wählen wir „Always“ – er soll also immer wieder selbst neu starten.
+Unter dem Punk „Command & logging“ solltest du für die Console „Interactive & TTY“ auswählen.
+(11) – Button „Deploy the container“ klicken
+
http://IP-DEINES-RASPBERRY:3000 → http://192.168.178.52:3000
+
Mit dem Default User und Passwort (admin/admin) kannst du dich einloggen und direkt das Passwort ändern.
+
Wir loggen uns jetzt wieder in der Grafana WebGui auf dem Raspberry ein (IP-DEINES_RASPBERRYS:3000).
Hier wählen wir auf der linken Seite das Zahnrad und „Data sources“ aus, dann klicken wir auf den Button „Add data source“ und sagen zum Schluss wir wollen eine InfluxDB hinzufügen:
Jetzt müssen wir nur noch ein paar Angaben zu der Datenbank machen. Damit es einfacher zu handhaben ist, verzichte ich hier vollkommen auf Username / Passwörter. Bedeutet die Datenbank ist frei zugänglich. Da dies alles nur in unserem Netzwerk läuft, ist das kein Problem. Bedenke aber das man unter anderen Umständen immer User und Passwörter vergeben sollte.
+Zurück zu unseren Einstellungen.
Unter Name kannst du einen Namen vergeben der dann später als Quelle in deinem Dashboard auswählbar ist.
Im Bereich HTTP und URL gibst du die IP deines Raspberrys ein auf dem die Datenbank läuft, gefolgt von dem Port 8086
Die restlichen Einstellungen können so bleiben.
Etwas weiter unten musst du noch den Datenbank Namen angeben aus dem die Daten gelesen werden sollen. Du erinnerst dich? Wir haben diesen weiter oben in die telegraf.conf eingetragen. In meinem Fall als „raspberry_live„.
Über den Button „Save & test“ prüfen wir die Verbindung. Ein grüner Haken und „Data source is working„, zeigt uns an, das alles funktioniert hat:
Was wäre ein Raspberry Pi Monitoring ohne ein Dashboard?
Damit wir bei Grafana ein solches sehen können, müssten wir uns selbst eins erstellen oder – was ich hier bevorzuge – ein fertiges Dashboard importieren.
Du kannst dir auf der Grafana Labs Seite alle verfügbaren Dashboards ansehen und entsprechend suchen. Wir wollen ja ein speziell für einen Raspberry Pi erstelltes nutzen, daher suchen wir auch nach „Raspberry“.
Ich denke du wirst dann bei deiner Suche direkt auf dieses hier treffen: Raspberry Pi Monitoring
Dieses nehmen wir auch direkt. Wie?! Ganz einfach: Kopiere dir die ID oben Rechts „10578„.
Dann öffnest du bei dir deine Grafana Umgebung (IP-DEINES_RASPBERRYS:3000) und gehst über den Menüpunkt „Dashboards“ auf „+ Import„:
Hier trägst du die gerade kopierte oder gemerkte ID des Dashboards ein (10578) und betätigst den „Load“ Button.
+
Jetzt könntest du den Namen des Dashboards ändern und musst auf jeden Fall die Verbindung zu den Daten – also zu der influxDB – angeben.
Diese hatten wir ja gerade eingerichtet und du solltest sie in dem Drop-Down-Feld auswählen können. In meinem Fall „Raspberry Pi Monitoring“
Ist alles eingestellt, klicken wir auf den „Import“ Button und sehen einige Sekunden später bereits unser Dashboard mit Daten.
Ab jetzt kannst du dich einfach mal in Ruhe durch alle Punkte klicken und dir das Dashboard anschauen. Je länger dein Raspberry läuft, je mehr Daten erscheinen. Oben Rechts kannst du die Aktualisierungsrate einstellen. Default ist 1 Minute.
Herzlichen Glückwunsch, dein Raspberry Pi Monitoring ist somit fertig und funktionsfähig. Viel Spaß damit!
+
https://www.youtube.com/watch?v=gEIgg5zHuIU
+the influxdb data explorer, select a quer and cop from the script editor
+
https://darkwolfcave.de/raspberry-pi-monitoring-grafana-installieren/
+Willkommen zurück! Na?! Kopf wieder etwas abgekühlt und aufnahmefähig? 🙂
Dann lass uns direkt weitermachen und die letzten paar Dinge erledigen.
Was jetzt kommt, wird wieder direkt auf dem Raspberry installiert. Also nicht als Container.
Dazu wie immer per SSH mit deinem pi verbinden.
Damit wir Zugriff auf die Quelle von influxDB haben, um uns Pakete herunterladen zu können, besorgen wir uns einen Key und speichern ihn auf dem Raspberry:
+wget -q https://repos.influxdata.com/influxdata-archive_compat.key
+cat influxdata-archive_compat.key | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/influxdata-archive_compat.gpg > /dev/null
+echo 'deb [signed-by=/etc/apt/trusted.gpg.d/influxdata-archive_compat.gpg] https://repos.influxdata.com/debian stable main' | sudo tee /etc/apt/sources.list.d/influxdata.list
+sudo rm -f /etc/apt/trusted.gpg.d/influxdb.gpg
+Dann aktualisieren wir unsere Quellen und installieren apt-transport-https, was wir für den weiteren Schritt benötigen.
+sudo apt-get update && sudo apt-get install apt-transport-https
+Um später auch Updates erhalten zu können, fügen wir noch einen Eintrag in unserer Paketquelle hinzu:
+sudo echo 'deb [signed-by=/etc/apt/trusted.gpg.d/influxdb.gpg] https://repos.influxdata.com/debian stable main' | sudo tee /etc/apt/sources.list.d/influxdata.list
+Final installieren wir endlich Telegraf:
+sudo apt-get update && sudo apt-get install telegraf
+
Es sollte jetzt von repos.influxdata.com das Paket für telegraf heruntergeladen und installiert werden.
Für mehr Informationen, und weiterführende Konfigurationen, schaue dir die Installationsanleitung von Telegraf an.
Uns fehlen noch ein paar Konfigurationen, damit wir für unser Raspberry Pi Monitoring auch alle benötigten Informationen bekommen, und in unserer Datenbank speichern können.
Dafür öffnen wir eine config Datei von telegraf:
sudo nano /etc/telegraf/telegraf.conf
+Viel Spaß beim scrollen…. ja diese Datei ist WIRKLICH gefühlt unendlich lang. Aber keine Sorge, wir machen da nicht sehr viel mit und müssen es auch für unsere Anforderungen nicht.
+Suche mal nach „OUTPUT PLUGINS“ und dann nach [[output.influxdb]]. Unter diesem Punkt geben wir jetzt an, wo sich unsere influxdb-Datenbank befindet.
Bei dem letzten auskommentierten (#) urls Eintrag entfernen wir einfach die Raute(#) und können es im Prinzip so lassen. Die 127er IP ist der localhost. Da die influxdb ja direkt auf dem Raspberry läuft, kann diese so erreicht werden.
Falls du noch einen zweiten Raspberry hast, würdest du bei diesem hier die IP des Hosts eingeben, auf dem die influxdb-Datenbank läuft.
Ein wenig unter diesem Eintrag entfernen wir auch die Raute(#) vor dem „database = “ und geben unserer Datenbank einen Namen.
Diese wird dann später automatisch angelegt und wir brauchen uns da nicht selbst drum kümmern.
Ich habe meine hier „raspberry_live“ genannt, damit ich später weiß von welchem meiner raspberrys die Daten sind. Bei einem weiteren pi würde ich zum Beispiel „raspberry_test“ oder sowas nehmen.
Ich greife jetzt einen Schritt vor, denn ich nutze für mein Raspberry Pi Monitoring bei Grafana ein fertiges Dashboard. Und der Entwickler gibt noch ein paar Parameter an, die man in die telegraf.conf eintragen sollte. Daher scrollen wir jetzt sehr weit nach unten bis du „INPUT PLUGINS“ sehen kannst. Direkt da drunter fügst du dann folgendes ein:
+#In order to monitor both Network interfaces, eth0 and wlan0, uncomment, or add the next:
+[[inputs.net]]
+[[inputs.netstat]]
+[[inputs.file]]
+files = ["/sys/class/thermal/thermal_zone0/temp"]
+name_override = "cpu_temperature"
+data_format = "value"
+data_type = "integer"
+[[inputs.exec]]
+commands = ["/opt/vc/bin/vcgencmd measure_temp"]
+name_override = "gpu_temperature"
+data_format = "grok"
+grok_patterns = ["%{NUMBER:value:float}"]
+
Jetzt speichere die Datei und verlasse sie. Denn hier sind wir erstmal mit fertig.
Damit wir auf dem Raspberry auch auf die Werte von GPU usw. zugreifen dürfen, müssen wir den telegraf User noch in eine Gruppe hinzufügen:
sudo usermod -G video telegraf
+Noch haben unsere Änderungen keine Wirkung, daher starten wir den Service telegraf einmal neu:
+sudo service telegraf restart
+Ab jetzt sollten Daten gesammelt und in die Datenbank geschrieben werden.
Was weiterhin fehlt ist das Dashboard, damit wir auch etwas sehen, und die Konfiguration zur Datenbank, damit Grafana auch weiß woher die Daten kommen sollen!
https://docs.influxdata.com/influxdb/v2.6/write-data/no-code/use-telegraf/manual-config/
+
create database/bucket in influxdb
+then, edit telegraf.conf as described in section above but use bucket, token, etc.
+need a section [[output.influxdb_v2]]
++