☁️ IoT Cloud Platform: Panduan Lengkap

# /etc/mosquitto/conf.d/aws-bridge.conf

# Bridge connection ke AWS IoT Core
connection aws-iot-bridge
address xxxxxxxxxx-ats.iot.ap-southeast-1.amazonaws.com:8883

# Topics: publish local data ke AWS
topic sensor/+/data out 1 $aws/things/+/shadow/update
topic sensor/+/status out 0

# Topics: subscribe dari AWS (commands)
topic cmd/+ in 1

# TLS/SSL Configuration
bridge_cafile /etc/mosquitto/certs/AmazonRootCA1.pem
bridge_certfile /etc/mosquitto/certs/device-certificate.pem.crt
bridge_keyfile /etc/mosquitto/certs/private.pem.key

# Connection settings
bridge_protocol_version mqttv311
cleansession true
notifications true
restart_timeout 30
keepalive_interval 60

# Local broker tetap berjalan
listener 1883
allow_anonymous false
password_file /etc/mosquitto/passwd

# EMQX mendukung bridging ke multiple cloud secara native
# Konfigurasi via EMQX Dashboard atau emqx.conf

# Bridge ke AWS IoT Core
bridges {
  aws_iot {
    enable = true
    server = "xxxxx-ats.iot.ap-southeast-1.amazonaws.com:8883"
    clientid = "emqx-bridge"
    ssl {
      enable = true
      cacertfile = "etc/certs/AmazonRootCA1.pem"
      certfile = "etc/certs/device.pem.crt"
      keyfile = "etc/certs/device.pem.key"
    }
    ingress {
      remote_topic = "cmd/#"
      local_topic = "cloud/${topic}"
    }
    egress {
      local_topic = "sensor/#"
      remote_topic = "devices/${topic}"
    }
  }

  # Bridge ke Azure IoT Hub
  azure_iot_hub {
    enable = true
    server = "myhub.azure-devices.net:8883"
    clientid = "sensor001"
    username = "myhub.azure-devices.net/sensor001/api-version=2021-04-12"
    password = "SAS_TOKEN_HERE"
    ssl { enable = true }
  }

  # Bridge ke GCP Pub/Sub via webhook
  gcp_pubsub {
    enable = true
    type = "http"
    url = "https://pubsub.googleapis.com/v1/projects/my-project/topics/iot-data:publish"
    method = "post"
    headers = { "Authorization" = "Bearer TOKEN" }
  }
}

#include <WiFiClientSecure.h>
#include <MQTTClient.h>
#include <ArduinoJson.h>
#include <Update.h>

// AWS IoT Jobs - OTA Update Handler
WiFiClientSecure net;
MQTTClient client(512);

String currentFirmware = "2.1.0";

void handleJobExecution(String& payload) {
    StaticJsonDocument<512> doc;
    deserializeJson(doc, payload);

    JsonObject job = doc["execution"]["jobDocument"];
    String url = job["url"];
    String version = job["version"];

    Serial.printf("OTA Update: v%s → v%s\n",
                  currentFirmware.c_str(), version.c_str());

    // Download dan flash firmware
    HTTPClient http;
    http.begin(url);
    int httpCode = http.GET();

    if (httpCode == 200) {
        int contentLength = http.getSize();
        if (Update.begin(contentLength)) {
            Update.writeStream(*http.getStreamPtr());
            if (Update.end()) {
                Serial.println("Update berhasil! Rebooting...");
                ESP.restart();
            }
        }
    }

    // Report result ke AWS IoT
    String statusTopic = "$aws/things/" + String(THING_NAME) +
                        "/jobs/" + String(doc["execution"]["jobId"]) +
                        "/update";
    String status = "{\"status\":\"SUCCEEDED\",\"version\":\"" +
                    version + "\"}";
    client.publish(statusTopic.c_str(), status.c_str());
}

-- Rule 1: Simpan semua data sensor ke DynamoDB
SELECT
  topic(2) as device_id,
  timestamp() as ts,
  suhu, kelembaban, tekanan
FROM 'sensor/+/data'

-- Rule 2: Kirim alarm jika suhu > 35°C
SELECT
  topic(2) as device_id,
  suhu as current_temp,
  35 as threshold,
  'HIGH_TEMPERATURE' as alarm_type
FROM 'sensor/+/data'
WHERE suhu > 35

-- Rule 3: Transform data untuk analytics
SELECT
  topic(2) as device_id,
  timestamp() as epoch,
  suhu * 9/5 + 32 as suhu_fahrenheit,
  ROUND(kelembaban, 0) as humidity_pct,
  CASE
    WHEN suhu > 35 THEN 'CRITICAL'
    WHEN suhu > 30 THEN 'WARNING'
    ELSE 'NORMAL'
  END as status
FROM 'sensor/+/data'

import json
import boto3
from datetime import datetime

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('IoT_SensorData')
sns = boto3.client('sns')

def lambda_handler(event, context):
    """Dipanggil oleh IoT Rules Engine setiap ada data sensor."""

    device_id = event['device_id']
    suhu = float(event['suhu'])
    kelembaban = float(event['kelembaban'])
    timestamp = event.get('ts', int(datetime.now().timestamp()))

    # 1. Simpan ke DynamoDB
    table.put_item(Item={
        'device_id': device_id,
        'timestamp': timestamp,
        'suhu': suhu,
        'kelembaban': kelembaban
    })

    # 2. Cek threshold dan kirim alarm
    if suhu > 35.0:
        sns.publish(
            TopicArn='arn:aws:sns:region:account:iot-alerts',
            Subject=f'⚠️ SUHU TINGGI - {device_id}',
            Message=f'Device {device_id}: Suhu {suhu}°C melebihi threshold 35°C!'
        )

    # 3. Hitung rata-rata per jam
    check_hourly_average(device_id)

    return {'statusCode': 200, 'body': 'OK'}

def check_hourly_average(device_id):
    """Cek rata-rata suhu per jam, trigger alert jika abnormal."""
    from boto3.dynamodb.conditions import Key
    import time

    one_hour_ago = int(time.time()) - 3600
    response = table.query(
        KeyConditionExpression=Key('device_id').eq(device_id) &
                               Key('timestamp').gte(one_hour_ago)
    )
    items = response['Items']
    if items:
        avg_temp = sum(i['suhu'] for i in items) / len(items)
        if avg_temp > 32:
            sns.publish(
                TopicArn='arn:aws:sns:region:account:iot-alerts',
                Subject=f'📊 Rata-rata suhu tinggi - {device_id}',
                Message=f'Rata-rata suhu 1 jam: {avg_temp:.1f}°C'
            )

# ARSITEKTUR SMART FARMING DENGAN IoT CLOUD
#
# LAYER 1: FIELD SENSORS
# ├── ESP32 #1: Suhu, Kelembaban tanah, Cahaya
# ├── ESP32 #2: pH tanah, Nutrisi (EC), Suhu air
# └── ESP32 #3: Kamera (pest detection), Curah hujan
#
# LAYER 2: GATEWAY
# └── Raspberry Pi 4
#     ├── MQTT Broker (Mosquitto) — lokal
#     ├── Data buffering (SQLite) — offline mode
#     ├── MQTT Bridge ke AWS IoT Core
#     └── Rule engine lokal (irrigasi otomatis)
#
# LAYER 3: CLOUD (AWS IoT Core)
# ├── Rules Engine → DynamoDB (data storage)
# ├── Rules Engine → Lambda → SNS (alert)
# ├── Rules Engine → S3 (data archive)
# └── Device Shadow (remote config)
#
# LAYER 4: DASHBOARD & ALERTING
# ├── Grafana Dashboard (monitoring real-time)
# ├── Mobile App (React Native)
# ├── Email/SMS Alerts (via SNS)
# └── Prediksi panen (SageMaker ML)
#
# DATA FLOW:
# Sensor → ESP32 → MQTT → Gateway → AWS IoT → DynamoDB
# Commands: Dashboard → AWS IoT → MQTT → Gateway → ESP32 → Relay