ESP32 OTA-Update im Vergleich: Web, GitHub, HTTPS
ESP32 OTA-Update im Vergleich: ArduinoOTA, Web-Upload, HTTPS-Pull von GitHub Releases und USB, mit Partitionen, Sicherheit und Rollback.
- Autor
Mauro Brambilla- Veroffentlicht
- Lesezeit
- 10 Min.
- Kategorie
- Vergleiche

Kurz gesagt
ArduinoOTA und Web-Upload schieben eine .bin durchs LAN, beim HTTPS-Pull holt sich das Board sie selbst, und alle drei brauchen zwei OTA-App-Slots. OpenGizmo nutzt keins davon: Es flasht per USB.
Ein ESP32-OTA-Update ersetzt die laufende Firmware per WLAN: Der Chip schreibt das neue Image in die freie von zwei OTA-App-Partitionen und startet dann davon neu. Du kannst die .bin vom Computer schieben (ArduinoOTA), über eine Seite auf dem Board hochladen oder das Board sie per HTTPS von einem Server oder von GitHub Releases holen lassen. Alle drei brauchen eine Partitionstabelle mit zwei App-Slots.
Dieser Beitrag vergleicht diese Methoden, dazu das normale Flashen per USB, nach Aufwand, Sicherheit, Rollback und Flash-Bedarf. Die OTA-Fakten stammen aus der Dokumentation und dem Quellcode von ESP-IDF und Arduino-ESP32, im Text verlinkt. Die OpenGizmo-Fakten stammen aus den drei Firmware-Repositories, die ich für diesen Beitrag gelesen habe. Ich habe keine der OTA-Methoden auf Hardware ausprobiert, also findest du hier keine Benchmarks.
Wie funktioniert ein ESP32-OTA-Update?
OTA heißt Over-the-Air: Die bereits laufende Firmware empfängt die nächste und installiert sie. Espressifs OTA-Dokumentation sagt, dass die OTA-Funktionen das neue Image in den Slot schreiben, der nicht fürs Booten ausgewählt ist, und erst nach der Prüfung wird die OTA-Data-Partition aktualisiert, damit dieses Image beim nächsten Start verwendet wird.
Deshalb ist ein abgebrochener Download harmlos: Die laufende App wird nie angefasst. Die Doku nennt dafür eine Grenze. Der sichere Weg gilt für Anwendungen. Bootloader, Partitionstabelle und Datenpartitionen sind auf derselben Seite ein "unsafe update", denn ein Stromausfall beim letzten Kopieren kann das Gerät lahmlegen.
Das Minimum-Layout steht auf derselben Seite: "at least two OTA app slot partitions (i.e., ota_0 and ota_1) and an OTA Data Partition". Die Anleitung zur Partitionstabelle zeigt die ganze Flash-Karte. Für diesen Vergleich zählt nur eine Zahl: die Slot-Größe, denn das neue Image muss in einen anderen Slot passen als den, aus dem gerade die Firmware läuft.
ArduinoOTA, Web-Upload oder HTTPS-Pull: welches?
Der Unterschied liegt darin, wer die Übertragung startet und woher die .bin kommt. Hier sind die vier Wege nebeneinander.

| Methode | Wer startet es | Netzwerk | Zwei OTA-Slots | Schutz ab Werk |
|---|---|---|---|---|
| ArduinoOTA | Dein Computer, mit espota.py oder PlatformIO | Gleiches LAN, gefunden per IP oder mDNS | Ja | Optionales Passwort; Übertragung über einfaches TCP |
| Web-Upload | Du, im Browser | Gleiches LAN, HTTP-Seite auf dem Board | Ja | Keiner, oder die Basic Auth, die du ergänzt |
| HTTPS-Pull | Das Board, per Timer oder Knopf | Jedes Netz, das den Server erreicht | Ja | TLS, wenn du ein Zertifikat mitgibst |
| USB-Reflash | Du, mit einem Kabel | Keins | Nein | Physischer Zugang |
ArduinoOTA: vom Computer schieben
Die ArduinoOTA-Bibliothek im Arduino-ESP32-Core lauscht standardmäßig auf Port 3232 und nennt das Board esp32- plus seine MAC-Adresse, solange du nicht setHostname() aufrufst. Ein Tool schickt eine UDP-Einladung, und das Board öffnet eine TCP-Verbindung zurück zum Computer, um das Image zu holen. Du musst handle() in loop() aufrufen, sonst antwortet das Board nie.
Laut Quellcode wird das Passwort mit SHA-256 gehasht und in einem Challenge-Response mit PBKDF2-HMAC-SHA256 geprüft. Das Image selbst kommt, soweit der Quellcode es zeigt, über einfaches TCP, mit einer MD5-Prüfung nur für die Integrität. mDNS ist standardmäßig an, was bequem ist und zugleich die Stelle, an der .local-Namen unter Android scheitern, und bei manchen Routern.
PlatformIO unterstützt es direkt. Die Espressif-32-Doku sagt, du setzt upload_protocol = espota und upload_port auf die IP-Adresse oder den mDNS-Namen, mit --auth in upload_flags für das Passwort. Wenn du auch die Toolchain noch auswählst, erklärt Arduino IDE vs. PlatformIO die Abwägung.
Web-Upload: eine Seite auf dem Board
Ein Web-Updater liefert ein Upload-Formular direkt vom ESP32 aus. Espressifs Seite zum OTA-Web-Update geht das Beispiel OTAWebUpdater durch: Rufe http://esp32.local auf, melde dich mit den Standardwerten admin und admin an und wähle die kompilierte Binärdatei. Die Seite sagt, dass Board und Computer im selben Netzwerk sein müssen, und verliert kein Wort darüber, wie man diesen Login ändert.
ElegantOTA verpackt dieselbe Idee in eine schönere Seite. Die kostenlose Edition kann Firmware- und Dateisystem-Updates, MD5-Prüfung und optionale HTTP Basic Auth, unter der AGPL-3.0-Lizenz. Auto-Update und direkter Download sind Pro-Funktionen. Mit ESPAsyncWebServer brauchst du das Build-Flag ELEGANTOTA_USE_ASYNC_WEBSERVER=1, und die README warnt, dass du den synchronen und den asynchronen Server nicht in einer Firmware betreiben kannst.
Die Schwachstelle ist unverschlüsseltes HTTP. Ein Passwort, das in ein HTTP-Formular getippt wird, läuft unverschlüsselt durch dein WLAN, dieselbe Grenze wie bei einem offenen Captive Portal, wie der Provisioning-Vergleich erklärt. In einem Heimnetz mag das vertretbar sein. In einem geteilten Netz nicht.
HTTPS-Pull: das Board holt das Image
Beim Pull entscheidet das Board, wann es updatet. In ESP-IDF erledigt esp_https_ota() das in einem Aufruf ab einer URL, und mit esp_https_ota_begin(), perform() und finish() steuerst du die Schleife selbst. Im Arduino-Core macht HTTPUpdate dieselbe Arbeit. Es schickt die aktuelle Version in einem x-ESP32-version-Header mit und wertet eine Antwort 204 oder 304 als "kein Update", sodass der Server entscheiden kann, was er sendet.
Das ist die einzige Methode, die übers Internet funktioniert und niemanden vor Ort braucht. Sie ist auch die, bei der die Sicherheitsdetails am meisten zählen, deshalb bekommen sie unten einen eigenen Abschnitt.
USB-Reflash: gar kein OTA
Ein USB-Flash braucht nur einen App-Slot, das Board in Reichweite und ein Kabel. Das ist es, was der Browser-Flasher tut, und ich komme unten mit den OpenGizmo-Zahlen darauf zurück.
Wie updatest du einen ESP32 von GitHub Releases?
GitHub Releases ist ein kostenloser Ort für versionierte .bin-Dateien, und das Board kann sie per HTTPS-Pull holen. Drei Details entscheiden, ob es klappt.
- Lade das App-Image hoch, nicht das zusammengeführte Flash-Image. Ein OTA-Update schreibt ein App-Image in einen Slot, also lade nur die App hoch. Eine zusammengeführte Datei enthält auch Bootloader und Partitionstabelle, die kein App-Image sind. Die OpenGizmo-Releases veröffentlichen die App allein bereits als
release-firmware.bin, neben den Teilen für Bootloader, Partitionstabelle undboot_app0. - Rechne mit einer Weiterleitung. Die Doku zu Release-Assets von GitHub sagt, Clients sollten sowohl eine 200- als auch eine 302-Antwort behandeln. Der Konstruktor von HTTPUpdate schaltet Weiterleitungen laut Quellcode standardmäßig ab, also lässt eine 302 das Update scheitern, bis du seine Methode
setFollowRedirects()aufrufst. In ESP-IDF ergänzt die HTTPS-OTA-Doku, dass die CA-Zertifikate der Weiterleitungsziele ebenfalls incert_pemstehen müssen. - Achte auf das Rate Limit. Die REST-API erlaubt ohne Authentifizierung 60 Anfragen pro Stunde und IP-Adresse. Ich habe nicht geprüft, ob einfache Asset-Downloads dazuzählen, also frag selten ab: Einmal am Tag reicht für ein Schreibtisch-Gadget locker.
Ein sauberer Entwurf trennt Prüfung und Download: Frag eine winzige Versionsdatei ab und hol die .bin nur, wenn die Nummer höher ist. Die Release-API listet außerdem einen SHA-256-digest für jedes Asset. Für die release-firmware.bin des Tickers liefert sie sha256:647b987e..., was ich am 14. November 2026 aus der API gelesen habe, sodass ein Board ihn mit dem Digest dessen vergleichen könnte, was es geschrieben hat.
Ich veröffentliche hier kein Codebeispiel, weil ich für diesen Beitrag keins kompiliert habe. Die oben genannten API-Aufrufe stehen in der verlinkten Doku, und jeder hat dort ein Beispiel.
Welches Partitions-Layout braucht OTA?
OTA braucht eine OTA-Data-Partition und zwei OTA-App-Slots, jeder groß genug für deine App. An der Slot-Größe bleiben Projekte hängen. Der Arduino-ESP32-Core liefert mehrere Tabellen mit, und ich habe ihre Definitionen gelesen, um sie mit einer echten Firmware zu vergleichen: der App des Gizmo Ticker v1.2.0, die laut ihrem GitHub-Release 1.796.736 Byte groß ist.

| Tabelle (Arduino-ESP32-Core) | App-Slots | Slot-Größe (Byte) | Slot-Größe (MiB) | Passt die App mit 1.796.736 B? |
|---|---|---|---|---|
| huge_app.csv | 1 (ota_0) | 0x300000 = 3.145.728 | 3,00 | Ja, aber ohne zweiten Slot |
| default.csv | 2 | 0x140000 = 1.310.720 | 1,25 | Nein |
| min_spiffs.csv | 2 | 0x1E0000 = 1.966.080 | 1,88 | Ja, mit 169.344 B Reserve |
| default_8MB.csv | 2 | 0x330000 = 3.342.336 | 3,19 | Ja, braucht 8 MB Flash |
Die Definitionen stehen in den Core-Dateien default.csv, min_spiffs.csv, default_8MB.csv und huge_app.csv. Alle vier legen nvs auf 0x9000 mit 0x5000 Byte und die erste App auf 0x10000. Die Anleitung zur Partitionstabelle listet diese und die übrigen Schemata vollständig auf. Die 1,25-MiB-Slots der Standardtabelle sind die Falle: Eine Firmware mit TLS-Stack, asynchronem Webserver und einer eingebauten Web-App kann größer sein, und das Update scheitert.
Zwei weitere Regeln aus Espressifs Anleitung zu Partitionstabellen: App-Partitionen müssen auf 64-KB-Grenzen (0x10000) liegen, und die OTA-Data-Partition ist 0x2000 Byte groß. Die Tabelle zu ändern liegt selbst außerhalb des sicheren OTA-Wegs, der Wechsel von einer Ein-Slot- auf eine Zwei-Slot-Tabelle ist also ein einmaliger USB-Flash.
Wie machst du OTA sicher: HTTPS, Signatur und Rollback?
Es gibt vier getrennte Schutzmaßnahmen, und jede beantwortet eine andere Frage: Ist das der richtige Server, ist das Image von mir, ist es kaputt, und ist es älter als das, was ich schon laufen habe.
| Frage | Mechanismus | Was es braucht | Was es nicht leistet |
|---|---|---|---|
| Ist das der richtige Server? | TLS mit cert_pem oder dem Zertifikatsbundle | Ein Root-Zertifikat im Flash, oder crt_bundle_attach | Beweist nicht, dass die Datei von dir ist |
| Ist dieses Image von mir? | Signierte Images: Secure Boot v2, oder die reine Software-Signaturprüfung | Einen Signaturschlüssel; Secure Boot v2 brennt eFuses | Der reine Software-Modus hält keinen Angreifer auf, der in den Flash schreiben kann |
| Ist dieses Image kaputt? | Rollback auf den vorherigen OTA-Slot | Zwei Slots, ein Bootloader mit der Rollback-Option | Nur OTA-Slots werden zurückgerollt, keine Factory-App |
| Ist dieses Image älter? | Anti-Rollback mit einer Sicherheitsversion im eFuse | Eine Sicherheitsversion in der App, geprüft gegen den eFuse | Nicht rückgängig zu machen, sobald der eFuse geschrieben ist |
Serverprüfung. Die ESP-IDF-Seite sagt, dass das Root-Zertifikat im PEM-Format in cert_pem gehört, und empfiehlt die Root des Servers, nicht ein Zwischenzertifikat, weil Roots am längsten gültig sind. Sie sagt auch, dass ein nicht gesetzter Transport standardmäßig TLS nutzt, eine http://-URL also scheitert, solange CONFIG_ESP_HTTPS_OTA_ALLOW_HTTP nicht aktiviert ist. Alternativ prüft crt_bundle_attach gegen das ESP x509 Certificate Bundle.
Das betrifft auch OpenGizmos eigenen Code. Der Marktdaten-Client des Gizmo Ticker ruft in api.cpp clientSecure.setInsecure() auf, was den Datenverkehr verschlüsselt, aber jedes Zertifikat akzeptiert. Für einen Kryptokurs ist das ein fairer Kompromiss. Für Firmware wäre er schlecht, denn wer in deinem Netz den Server nachahmen kann, könnte dir Code unterschieben. Ein OTA-Client muss den Server prüfen.
Signatur. Espressifs Seite zu Secure Boot v2 sagt, dass die App bei jedem OTA-Update geprüft wird und dass Secure Boot v2 beim klassischen ESP32 die Chip-Revision v3.0 oder neuer braucht. Es aktiviert sich über eFuses, plane die Schlüssel also vorher. Der reine Software-Modus prüft Signaturen während des OTA, und die Seite warnt, dass er nicht vor einem Angreifer mit Schreibzugriff auf den Flash schützt.
Rollback. Das Rollback von ESP-IDF ist eine Bootloader-Option, CONFIG_BOOTLOADER_APP_ROLLBACK, die laut OTA-Seite in ESP-IDF standardmäßig aktiviert ist. Ein neues Image startet im Zustand pending-verify, und wenn die App nie esp_ota_mark_app_valid_cancel_rollback() aufruft, überspringt der Bootloader es beim nächsten Start. Der Startcode von Arduino-ESP32 in esp32-hal-misc.c hat dafür Hooks, verifyOta() und verifyRollbackLater(). Ich habe nicht geprüft, ob der vorkompilierte Arduino-Bootloader das Rollback aktiviert hat, also kontrolliere deinen eigenen Build, bevor du dich darauf verlässt. Die Update-Klasse des Cores hat außerdem canRollBack() und rollBack(), um den anderen Slot von Hand zu booten.
ESPHome geht den verwalteten Weg: Seine OTA-Komponente bietet eine esphome-Plattform, eine web_server-Plattform und eine http_request-Plattform, die von einem Server zieht, mit automatisch aktiviertem Safe Mode. Wenn du nichts davon selbst bauen willst, schau dir ESPHome vs. eigene Firmware an.
Nutzt OpenGizmo OTA?
Nein. Ich habe die drei Firmware-Repositories und die gizmo-common-Versionen, die sie festlegen (v2.5.1 für den Ticker und den Reolink Switch, v2.4.0 für die Camera), nach ota, ArduinoOTA, HTTPUpdate, Update.h und esp_ota durchsucht und am 14. November 2026 keinen OTA-Code gefunden. Der Gizmo Ticker, der Gizmo Reolink Switch und die Gizmo Camera setzen alle board_build.partitions = huge_app.csv, und der Kommentar der Zeile selbst lautet "One 3 MB app slot (no wireless updates), the same in every OpenGizmo firmware". Du findest ihn in der platformio.ini des Tickers.

Updates laufen stattdessen über USB. Jede Projektseite hat eine Karte, die das neueste Release aus dem Browser flasht, wie die ESP-Web-Tools-Anleitung zeigt. Drei Dinge sorgen hier dafür, dass das gut funktioniert, und alle stehen in den Repositories:
- Die Web-App steckt in der Firmware.
gizmo-commonliefert sie aus Assets, die ins App-Image eingebaut sind, es gibt also eine Datei zu aktualisieren, kein separates Dateisystem-Image. - Die Einstellungen bleiben erhalten. Der Flasher schreibt vier Teile und löscht nie die
nvs-Region, daher behält ein USB-Update das gespeicherte WLAN und die Einstellungen. - Die Version ist sichtbar. Jeder Build meldet seine Version in
/api/device, und der Release-Workflow prüft, ob die Version neu ist, bevor er veröffentlicht.
Das hat seinen Preis: Du brauchst das Board und ein Kabel, und ein Board, das im Gehäuse steckt oder außer Reichweite montiert ist, ist mühsam zu aktualisieren.
Mit einem Slot ist ohnehin kein Platz für OTA. Die App-Größen in den Releases sind 1.796.736 Byte (Ticker v1.2.0), 1.778.336 (Reolink Switch v1.2.0) und 1.722.192 (Camera v1.0.0), also passt keine davon in die 1,25-MiB-Slots von default.csv.
Wie ließe sich OTA aufsetzen?
Das ist ein Plan, nichts, was ich gebaut habe. Das XIAO ESP32-S3 hat laut Seeeds Wiki 8 MB Flash, also ergibt default_8MB.csv zwei Slots mit je 3,19 MiB, in die jeweils die Apps von Ticker und Reolink passen. Den Flash des Camera-Boards solltest du an deinem Modul prüfen. Die Schritte wären:
- Ein Release mit der neuen Partitionstabelle per USB ausliefern, weil die Tabelle außerhalb des sicheren OTA-Wegs liegt. Der Flasher schreibt
release-partitions.binbereits nach 0x8000. - Einen HTTPS-Pull ergänzen, der das Release-Manifest oder eine Versionsdatei prüft und
release-firmware.binnur lädt, wenn sie neuer ist. - Den Server mit dem Zertifikatsbundle prüfen, nie mit
setInsecure(), und den SHA-256 des Assets vergleichen. - Das neue Image erst als gültig markieren, wenn Webserver und WLAN laufen, damit ein kaputtes Image zurückgerollt wird.
Der Preis: Der Flash enthält jetzt zwei Kopien der App, der App-Bereich wird also zwischen ihnen geteilt, und du musst Code schreiben, der entscheidet, wann ein Neustart bei einem Gerät, auf das jemand gerade schaut, vertretbar ist.
Welche ESP32-OTA-Methode solltest du nutzen?
Nimm ArduinoOTA mit PlatformIO, solange du entwickelst, weil es das Kabel aus dem Ändern-und-Testen-Zyklus nimmt. Nimm eine Web-Upload-Seite, wenn jemand anderes ein paar Boards updaten muss und du die Seite schützen kannst. Nimm einen HTTPS-Pull, wenn viele Boards außer Reichweite sind, und nur mit Zertifikatsprüfung, Größenprüfung und Rollback. Nimm USB, wenn das Board auf deinem Schreibtisch liegt, die Firmware klein ist und die Einstellungen erhalten bleiben sollen, und genau da steht OpenGizmo heute.
Die Grenze dieses Vergleichs: Ich habe die Doku und den Quellcode gelesen und keine der Methoden ausgeführt, also habe ich keine Zeiten, Fehlerraten oder Stromwerte. Das Erste, was du in deinem eigenen Projekt prüfen solltest, ist die Slot-Größe gegenüber deiner App. Schau dir dann an, wie der Flasher Releases baut und hochlädt, und lies den Beitrag zur Partitionstabelle, bevor du deine ändern willst.
Haufig gestellte Fragen
Finden Sie schnelle Antworten auf die haufigsten Fragen zu diesem Thema.
Ja, per HTTPS-Pull. Das Board fordert das .bin-Asset des Releases an, worauf GitHub mit einer Weiterleitung antwortet, der HTTP-Client muss ihr also folgen. Dann schreibt es die Datei in den freien OTA-Slot. HTTPUpdate im Arduino-ESP32-Core hat Weiterleitungen standardmäßig aus, du musst sie einschalten.
Autor
Mauro BrambillaLust, dein eigenes Gizmo zu bauen?
Such dir ein Open-Source-Projekt mit dem ESP32 aus und folge der Schritt-für-Schritt-Anleitung, von der Teileliste und der Verkabelung bis zur Firmware und zum ersten Start.





