ESP32 IoT Tutorial: Vom ersten Sketch zum Cloud-Sensor

Dieses ESP32 IoT Tutorial bringt Sie vom frisch ausgepackten Board zu einem mit der Cloud verbundenen Sensor, der Temperatur und Luftfeuchtigkeit veröffentlicht, Fernbefehle annimmt und über TLS mit der Cloud kommuniziert. Sie richten die Arduino IDE ein, verbinden sich mit dem WLAN, lesen einen DHT22 aus, veröffentlichen per MQTT an einen kostenlosen öffentlichen MQTT-Broker und übertragen denselben Sketch dann für den Echteinsatz auf einen privaten, verschlüsselten Broker.

Warum der ESP32 der Standard-Mikrocontroller für IoT ist

Die ESP32-Familie von Espressif vereint einen schnellen Dual-Core-Prozessor (oder je nach Variante einen Single-Core-RISC-V), integriertes WLAN und Bluetooth, zahlreiche GPIOs, analoge Eingänge und Hardwareunterstützung für TLS in einem Modul, das nur wenige Euro kostet. Er führt Arduino-Code, MicroPython und Espressifs eigenes ESP-IDF-Framework aus und hat eine riesige Community. Für jeden, der einen vernetzten Sensor, eine Relaissteuerung oder ein kleines Gateway baut, ist er meist das erste Board, das man ausprobiert.

Das bauen Sie in diesem Tutorial:

1. Ein Board, das sich mit Ihrem WLAN verbindet und sich automatisch neu verbindet.
2. Einen DHT22-Sensor, der alle zehn Sekunden JSON-Messwerte per MQTT veröffentlicht.
3. Eine ferngesteuerte LED, die durch Veröffentlichen von ON oder OFF auf ein Befehls-Topic geschaltet wird.
4. Ein Online/Offline-Status-Topic mithilfe der Last-Will-Funktion von MQTT.
5. Eine sichere Version mit TLS auf Port 8883 und privaten Zugangsdaten.

Was Sie brauchen

Noch kein Sensor zur Hand? Der Sketch meldet einen Fehler und läuft weiter, sodass Sie den MQTT- und LED-Teilen trotzdem folgen können.

Schritt 1: Die Arduino IDE für den ESP32 einrichten

1. Installieren Sie die Arduino IDE 2.x von der Arduino-Website.
2. Öffnen Sie Werkzeuge, Board, Boardverwalter, suchen Sie nach esp32 und installieren Sie esp32 by Espressif Systems. Falls es nicht erscheint, fügen Sie https://espressif.github.io/arduino-esp32/package_esp32_index.json unter Datei, Einstellungen, Zusätzliche Boardverwalter-URLs hinzu und suchen Sie erneut. Die offizielle Installationsanleitung für Arduino-ESP32 enthält Screenshots für jede Plattform.
3. Öffnen Sie Werkzeuge, Bibliotheken verwalten und installieren Sie PubSubClient von Nick O'Leary sowie DHT sensor library von Adafruit (bestätigen Sie die Abfrage, auch Adafruit Unified Sensor zu installieren).
4. Schließen Sie das Board an, wählen Sie Ihr Modell unter Werkzeuge, Board (für ein generisches DevKit ESP32 Dev Module) und den seriellen Port unter Werkzeuge, Port.

Testen Sie die Toolchain mit einem Blink-Sketch, bevor Sie weitermachen:

#define LED_PIN 2  // Onboard-LED bei den meisten ESP32-DevKit-Boards

void setup() {
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_PIN, HIGH);
  delay(500);
  digitalWrite(LED_PIN, LOW);
  delay(500);
}

Bleibt der Upload bei „Connecting...“ hängen, halten Sie die BOOT-Taste auf dem Board gedrückt, bis der Upload startet. Erscheint überhaupt kein Port, installieren Sie den USB-Seriell-Treiber für den Chip Ihres Boards (oft CP210x oder CH340) oder probieren Sie ein anderes Kabel. Manche Boards haben keine LED an GPIO 2; schließen Sie in diesem Fall eine LED mit einem 220-Ohm-Widerstand an GPIO 2 an.

Schritt 2: Den DHT22-Sensor verdrahten

Schließen Sie das DHT22-Modul wie folgt an:

Wenn Sie statt eines Moduls einen nackten Sensor mit vier Pins verwenden, ergänzen Sie einen 10-Kiloohm-Pull-up-Widerstand zwischen DATA und 3V3 und lassen den dritten Pin unbelegt. Meiden Sie GPIO 6 bis 11, die bei klassischen ESP32-Modulen für den Flash-Speicher reserviert sind, und verwenden Sie Strapping-Pins wie GPIO 0, 2, 12 und 15 nicht für Sensoren. Der DHT22 sollte nicht häufiger als alle zwei Sekunden ausgelesen werden.

Schritt 3: Die MQTT-Bausteine verstehen

MQTT ist ein Publish/Subscribe-Protokoll. Ihr ESP32 sendet Daten nicht an eine bestimmte Serveranwendung; er veröffentlicht Nachrichten auf Topics bei einem Broker, und jeder Client, der diese Topics abonniert hat, empfängt sie. Wenn Sie den vollständigen Hintergrund möchten, lesen Sie zuerst, was ein MQTT Broker leistet.

Für dieses ESP32 IoT Tutorial verwenden wir den kostenlosen öffentlichen MQTT-Broker unter broker.connectmq.com. Er akzeptiert anonyme Verbindungen auf Port 1883, solange jeder Client eine eindeutige, nicht leere Client ID verwendet. Alles, was auf dem öffentlichen MQTT-Broker veröffentlicht wird, ist für jeden lesbar; senden Sie also niemals Passwörter oder personenbezogene Daten und verwenden Sie ein eindeutiges Topic-Präfix, damit Ihre Nachrichten nicht mit denen anderer kollidieren. Der öffentliche MQTT-Broker erlaubt 64 KB pro Nachricht, 10 Nachrichten pro Sekunde und 10 Abonnements pro Client, weit mehr, als ein Sensor braucht.

Unsere Topics, wobei Sie k3v9 durch Ihre eigene zufällige Zeichenkette ersetzen:

connectmq/demo/esp32-k3v9/telemetry   JSON readings, published every 10 s
connectmq/demo/esp32-k3v9/status      "online" / "offline" (retained, Last Will)
connectmq/demo/esp32-k3v9/led/set     commands: ON or OFF
connectmq/demo/esp32-k3v9/led/state   current LED state (retained)

Für ein Demoprojekt reicht ein flaches Präfix. In der Industrie folgen Topics dagegen meist der ISA-95-Anlagenhierarchie, etwa acme/werk-muenchen/montage/linie-1/zelle-3/temperatur, und bilden damit einen Unified Namespace (UNS), den SPS, MES und Dashboards gemeinsam nutzen. Den Aufbau solcher Hierarchien zeigen die Beispiele für MQTT-Topic-Hierarchien.

Schritt 4: Der vollständige ESP32-IoT-Sketch

Erstellen Sie einen neuen Sketch, fügen Sie den folgenden Code ein und tragen Sie Ihren WLAN-Namen, Ihr Passwort und Ihr Topic-Präfix ein.

#include <WiFi.h>
#include <PubSubClient.h>
#include <DHT.h>

// ---------- Konfiguration ----------
const char* WIFI_SSID     = "YOUR_WIFI_SSID";
const char* WIFI_PASSWORD = "YOUR_WIFI_PASSWORD";

const char* MQTT_HOST = "broker.connectmq.com";
const uint16_t MQTT_PORT = 1883;
const char* TOPIC_PREFIX = "connectmq/demo/esp32-k3v9";  // k3v9 durch eigene Zeichenkette ersetzen

#define DHT_PIN 4
#define DHT_TYPE DHT22
#define LED_PIN 2
const unsigned long PUBLISH_INTERVAL_MS = 10000;
// -----------------------------------

DHT dht(DHT_PIN, DHT_TYPE);
WiFiClient net;
PubSubClient mqtt(net);

String clientId;
String topicTelemetry, topicStatus, topicLedSet, topicLedState;
unsigned long lastPublish = 0;
unsigned long lastReconnectAttempt = 0;

void connectWiFi() {
  if (WiFi.status() == WL_CONNECTED) return;
  Serial.printf("Connecting to Wi-Fi %s", WIFI_SSID);
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  unsigned long start = millis();
  while (WiFi.status() != WL_CONNECTED && millis() - start < 20000) {
    delay(500);
    Serial.print(".");
  }
  if (WiFi.status() == WL_CONNECTED) {
    Serial.printf("\nWi-Fi connected, IP %s\n", WiFi.localIP().toString().c_str());
  } else {
    Serial.println("\nWi-Fi connection failed, will retry");
  }
}

void setLed(bool on) {
  digitalWrite(LED_PIN, on ? HIGH : LOW);
  mqtt.publish(topicLedState.c_str(), on ? "ON" : "OFF", true);  // Retained-Zustand
}

void onMessage(char* topic, byte* payload, unsigned int length) {
  String message;
  for (unsigned int i = 0; i < length; i++) message += (char)payload[i];
  message.trim();
  Serial.printf("Received [%s] %s\n", topic, message.c_str());

  if (topicLedSet == topic) {
    if (message == "ON") setLed(true);
    else if (message == "OFF") setLed(false);
  }
}

bool connectMqtt() {
  Serial.printf("Connecting to MQTT %s:%u as %s\n", MQTT_HOST, MQTT_PORT, clientId.c_str());
  // Last Will: Der Broker veröffentlicht "offline" (retained), falls wir verschwinden
  bool ok = mqtt.connect(clientId.c_str(), topicStatus.c_str(), 1, true, "offline");
  if (ok) {
    Serial.println("MQTT connected");
    mqtt.publish(topicStatus.c_str(), "online", true);
    mqtt.subscribe(topicLedSet.c_str(), 1);
  } else {
    Serial.printf("MQTT connect failed, state=%d\n", mqtt.state());
  }
  return ok;
}

void publishReading() {
  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();
  if (isnan(temperature) || isnan(humidity)) {
    Serial.println("DHT22 read failed, check wiring");
    mqtt.publish(topicTelemetry.c_str(), "{\"error\":\"sensor_read_failed\"}");
    return;
  }
  char payload[128];
  snprintf(payload, sizeof(payload),
           "{\"temperature\":%.2f,\"humidity\":%.1f,\"rssi\":%d,\"uptime\":%lu}",
           temperature, humidity, WiFi.RSSI(), millis() / 1000);
  mqtt.publish(topicTelemetry.c_str(), payload);
  Serial.printf("Published %s\n", payload);
}

void setup() {
  Serial.begin(115200);
  pinMode(LED_PIN, OUTPUT);
  dht.begin();

  // Eindeutige Client ID aus der MAC-Adresse des Chips
  uint64_t mac = ESP.getEfuseMac();
  char id[32];
  snprintf(id, sizeof(id), "esp32-%04X%08X", (uint16_t)(mac >> 32), (uint32_t)mac);
  clientId = id;

  topicTelemetry = String(TOPIC_PREFIX) + "/telemetry";
  topicStatus    = String(TOPIC_PREFIX) + "/status";
  topicLedSet    = String(TOPIC_PREFIX) + "/led/set";
  topicLedState  = String(TOPIC_PREFIX) + "/led/state";

  connectWiFi();
  mqtt.setServer(MQTT_HOST, MQTT_PORT);
  mqtt.setCallback(onMessage);
  mqtt.setKeepAlive(30);
}

void loop() {
  if (WiFi.status() != WL_CONNECTED) {
    connectWiFi();
    return;
  }

  if (!mqtt.connected()) {
    unsigned long now = millis();
    if (now - lastReconnectAttempt > 5000) {  // nicht blockierender Neuversuch alle 5 s
      lastReconnectAttempt = now;
      if (connectMqtt()) lastReconnectAttempt = 0;
    }
    return;
  }

  mqtt.loop();

  if (millis() - lastPublish >= PUBLISH_INTERVAL_MS) {
    lastPublish = millis();
    publishReading();
  }
}

Laden Sie den Sketch hoch und öffnen Sie den seriellen Monitor mit 115200 Baud. Sie sollten die WLAN-Verbindung, die MQTT-Verbindung und alle zehn Sekunden einen veröffentlichten Messwert sehen.

Wie der Sketch aufgebaut ist

• Nicht blockierende Reconnects. Die Loop wartet nie in einer engen Wiederholungsschleife. Fällt WLAN oder MQTT aus, versucht sie es alle paar Sekunden erneut, während der restliche Code reaktionsfähig bleibt. Lange blockierende Schleifen sind eine häufige Ursache für Watchdog-Resets; der Leitfaden zum ESP32 MQTT Reconnect erklärt robustere Strategien.
• Last Will und Retained-Status. Der Broker speichert online als Retained-Status und ersetzt ihn automatisch durch offline, wenn das Board ohne sauberes Disconnect Strom oder Verbindung verliert.
• Retained-LED-Zustand. Jedes später abonnierende Dashboard erfährt sofort, ob die LED leuchtet.
• Kleine Payloads. Der Standard-Paketpuffer von PubSubClient beträgt 256 Bytes, in die dieser Payload bequem passt. Für größere JSON-Dokumente rufen Sie vor dem Verbinden mqtt.setBufferSize(1024) auf, wie in PubSubClient-Puffergröße beschrieben.

Schritt 5: Vom Computer aus testen

Beobachten Sie alles, was Ihr Board veröffentlicht:

mosquitto_sub -h broker.connectmq.com -p 1883 -i laptop-k3v9-sub -t "connectmq/demo/esp32-k3v9/#" -v

Die Retained-Nachrichten status und led/state sollten sofort erscheinen, danach alle zehn Sekunden Telemetrie:

connectmq/demo/esp32-k3v9/status online
connectmq/demo/esp32-k3v9/telemetry {"temperature":23.40,"humidity":48.2,"rssi":-58,"uptime":42}

Schalten Sie nun die LED aus einem zweiten Terminal:

mosquitto_pub -h broker.connectmq.com -p 1883 -i laptop-k3v9-pub -t "connectmq/demo/esp32-k3v9/led/set" -m ON
mosquitto_pub -h broker.connectmq.com -p 1883 -i laptop-k3v9-pub -t "connectmq/demo/esp32-k3v9/led/set" -m OFF

Die LED schaltet, und im Subscriber erscheint eine neue led/state-Nachricht. Ziehen Sie das Board ab, warten Sie etwa 45 Sekunden (das 1,5-Fache des Keep-Alive), und der Broker veröffentlicht offline auf dem Status-Topic. Das ist Ihr vollständiger IoT-Kreislauf: Erfassen, Veröffentlichen, Fernsteuerung und Präsenzerkennung.

Veröffentlichen Sie Befehle nicht mit dem Retain-Flag (-r). Ein Retained-Befehl würde bei jedem Reconnect des ESP32 erneut zugestellt.

Schritt 6: Wechsel zu einem privaten Broker mit TLS

Der öffentliche Broker ist ideal zum Lernen, aber ein echtes Gerät braucht Privatsphäre, Authentifizierung und Verschlüsselung. Mit ConnectMQ erhalten Sie einen privaten Broker mit generierten Zugangsdaten und einem Let's-Encrypt-Zertifikat auf Port 8883.

1. Registrieren Sie sich im ConnectMQ-Portal, wählen Sie den kostenlosen Serverless-Plan, erstellen Sie einen Broker und kopieren Sie den generierten Benutzernamen, das Passwort und die Client ID.
2. Laden Sie das Let's-Encrypt-Root-Zertifikat (ISRG Root X1) herunter, auf das die Zertifikatskette des Brokers verweist:

curl -o isrgrootx1.pem https://letsencrypt.org/certs/isrgrootx1.pem

3. Ändern Sie den Anfang des Sketches wie folgt. Nur die Includes, die Konfiguration, das Client-Objekt und der Connect-Aufruf ändern sich; alles andere bleibt gleich.

#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <PubSubClient.h>
#include <DHT.h>

const char* MQTT_HOST = "broker.connectmq.com";
const uint16_t MQTT_PORT = 8883;
const char* MQTT_USERNAME  = "YOUR_USERNAME";
const char* MQTT_PASSWORD  = "YOUR_PASSWORD";
const char* MQTT_CLIENT_ID = "YOUR_CLIENT_ID";
const char* TOPIC_PREFIX = "home/office/esp32-01";

// Den vollständigen Inhalt von isrgrootx1.pem zwischen den Markierungen einfügen
const char* ROOT_CA = R"EOF(
-----BEGIN CERTIFICATE-----
...paste the certificate body from isrgrootx1.pem here...
-----END CERTIFICATE-----
)EOF";

WiFiClientSecure net;
PubSubClient mqtt(net);

Ersetzen Sie in setup() die MAC-basierte Client ID durch die aus dem Portal und laden Sie das Zertifikat vor dem Verbinden:

  clientId = MQTT_CLIENT_ID;  // muss der mit Ihren Zugangsdaten ausgegebenen Client ID entsprechen
  net.setCACert(ROOT_CA);

Und übergeben Sie in connectMqtt() die Zugangsdaten zusammen mit dem Last Will:

  bool ok = mqtt.connect(clientId.c_str(), MQTT_USERNAME, MQTT_PASSWORD,
                         topicStatus.c_str(), 1, true, "offline");

Laden Sie erneut hoch. Der serielle Monitor sollte eine erfolgreiche Verbindung auf Port 8883 anzeigen. Prüfen Sie sie von Ihrem Computer mit denselben Zugangsdaten, oder öffnen Sie den MQTT-Client im Browser und den Live-Topic-Explorer im Portal, um die Messwerte eintreffen zu sehen. Beachten Sie, dass ConnectMQ Client IDs an die ausgegebenen Zugangsdaten bindet, daher braucht jedes Gerät einen eigenen Satz Zugangsdaten; wird ein Satz auf zwei Boards verwendet, trennen sie sich gegenseitig. Das Tutorial zu ESP32 MQTT über SSL behandelt den Umgang mit Zertifikaten ausführlicher, auch warum setInsecure() niemals in die Produktion gelangen sollte.

Schritt 7: Den Sensor für den Praxiseinsatz vorbereiten

Ein Sketch, der einen Nachmittag lang auf Ihrem Schreibtisch läuft, ist etwas anderes als ein Gerät, das ein Jahr lang unbeaufsichtigt läuft. Bevor Sie das Board an einem schwer erreichbaren Ort installieren, gehen Sie diese Checkliste durch:

1. Stabile Stromversorgung. Verwenden Sie ein hochwertiges 5-V-Netzteil mit mindestens 500 mA. WLAN-Übertragungen verursachen Stromspitzen, und billige Adapter führen zu Brownout-Resets, die wie Softwarefehler aussehen.
2. Sensorplatzierung. Halten Sie den DHT22 vom ESP32 selbst und von Spannungsreglern fern, die sich erwärmen und Messwerte um ein Grad oder mehr verfälschen. Ein kurzes Kabel und ein belüftetes Gehäuse helfen.
3. Ein Satz Zugangsdaten pro Gerät. Kopieren Sie niemals denselben Benutzernamen, dasselbe Passwort und dieselbe Client ID auf mehrere Boards. Vergeben Sie einen Satz pro Gerät, damit Sie einen widerrufen können, ohne die anderen anzufassen.
4. Echte Zeitstempel. Das Feld uptime ist fürs Debugging nützlich, die Auswertung braucht aber die Uhrzeit. Synchronisieren Sie die Uhr beim Start per NTP und ergänzen Sie jeden Messwert um einen Epoch-Zeitstempel, wie in ESP32-NTP-Zeitstempel für MQTT gezeigt.
5. Fernupdates. Auf eine Leiter zu steigen, um einen Sensor neu zu flashen, wird schnell lästig. Planen Sie von Anfang an Over-the-Air-Updates mit ESP32-OTA-Updates über MQTT ein.
6. Konfiguration ohne Neukompilieren. Fest einprogrammierte WLAN-Zugangsdaten sind für ein Board in Ordnung. Für mehrere nutzen Sie eine Captive-Portal-Bibliothek, damit jedes Gerät vor Ort konfiguriert werden kann.
7. Zustandsmeldungen. Veröffentlichen Sie weiterhin RSSI und Uptime. Eine langsam sinkende Signalstärke oder häufige Neustarts sind Frühwarnungen, dass ein Gerät bald offline gehen wird.

Keiner dieser Schritte ändert die MQTT-Logik, die Sie bereits geschrieben haben. Sie machen den Unterschied zwischen einer Demo und einem Sensor, den Sie vergessen können, weil er einfach weiter meldet.

Fehlerbehebung

Wenn mqtt.state() einen Wert ungleich null zurückgibt, weist diese Tabelle meist auf die Ursache hin:

Weitere häufige Probleme:

• Messwerte sind nan. Prüfen Sie die DHT22-Verdrahtung, den Pull-up-Widerstand und dass Sie nicht schneller als alle zwei Sekunden auslesen.
• Publish schlägt stillschweigend fehl. Die Nachricht ist größer als der PubSubClient-Puffer; vergrößern Sie ihn mit setBufferSize().
• Board startet zufällig neu. Schwache USB-Stromversorgung während der WLAN-Übertragung; versuchen Sie einen anderen Port oder einen aktiven Hub.
• Funktioniert auf 1883, aber nicht auf 8883. Das CA-Zertifikat fehlt oder ist unvollständig, oder das Netzwerk blockiert ausgehenden Port 8883.

Eine längere Checkliste finden Sie unter ESP32 kann sich nicht mit dem MQTT Broker verbinden.

Wie es weitergeht

Mit dieser Grundlage können Sie nahezu jeden vernetzten Sensor oder Aktor bauen. Gute nächste Schritte:

1. Ersetzen Sie handgebaute Strings durch ArduinoJson, wie in ESP32, ArduinoJson und MQTT gezeigt.
2. Tauschen Sie den DHT22 gegen einen genaueren BME280 über MQTT.
3. Betreiben Sie das Board mit Batterie dank ESP32 Deep Sleep und MQTT.
4. Schalten Sie echte Lasten sicher mit einem per MQTT gesteuerten ESP32-Relais.
5. Vergleichen Sie diesen Ansatz mit dem kürzeren, auf die LED fokussierten ESP32 MQTT Tutorial und dem Python-Weg in MicroPython umqtt auf dem ESP32.

Bringen Sie Ihren ESP32 mit ConnectMQ online

Wenn Ihr Prototyp bereit für echte Daten ist, geben Sie ihm ein privates Zuhause. Erstellen Sie unter app.connectmq.com ein kostenloses Konto im Serverless-Plan, ganz ohne Kreditkarte, legen Sie einen Broker an und flashen Sie die generierten Zugangsdaten in Ihren Sketch. Der kostenlose Plan unterstützt bis zu 25 Verbindungen, was eine kleine Sensorflotte plus ein oder zwei Dashboards abdeckt, und wenn Sie darüber hinauswachsen, skaliert ein größerer Plan Ihres verwalteten MQTT-Brokers auf Hunderte Geräte, ohne dass Sie Ihren Code ändern.

Häufig gestellte Fragen

Welches ESP32-Board eignet sich am besten für Einsteiger?

Ein Standard-ESP32-DevKit (oft als ESP32-WROOM-32 oder ESP32 Dev Module bezeichnet) ist der einfachste Einstieg, weil fast jedes Tutorial und jede Bibliothek es unterstützt. ESP32-S3- und ESP32-C3-Boards funktionieren ebenfalls mit dem Code aus diesem Tutorial.

Brauche ich ein Konto, um diesem ESP32 IoT Tutorial zu folgen?

Nein. Der erste Teil nutzt den öffentlichen MQTT-Broker broker.connectmq.com, der anonyme Verbindungen mit jeder eindeutigen, nicht leeren Client ID akzeptiert. Ein Konto brauchen Sie erst, wenn Sie zu einem privaten Broker mit TLS wechseln.

Warum trennt sich mein ESP32 ständig vom Broker?

Die häufigsten Ursachen sind zwei Geräte mit derselben Client ID, blockierender Code, der die Ausführung von mqtt.loop() verhindert, und ein schwaches WLAN-Signal. Prüfen Sie den RSSI-Wert in der Telemetrie und stellen Sie sicher, dass jedes Board eine eigene Client ID hat.

Unterstützt PubSubClient MQTT 5?

Nein. PubSubClient implementiert MQTT 3.1.1, das vom Broker vollständig unterstützt wird. Wenn Sie MQTT-5-Funktionen auf dem ESP32 benötigen, verwenden Sie stattdessen die esp-mqtt-Komponente von ESP-IDF.

Ist es sicher, setInsecure() für TLS auf dem ESP32 zu verwenden?

Nur für schnelle Experimente. setInsecure() verschlüsselt den Datenverkehr, überspringt aber die Serverprüfung und schützt daher nicht vor Identitätsfälschung. Laden Sie für alles, was über einen Test hinausgeht, das Root-CA-Zertifikat mit setCACert().