IoT Cloud Platforms — AWS IoT, Azure IoT & GCP IoT

# Device provisioning with AWS IoT
import boto3
import json
import time

iot = boto3.client('iot')

def provision_device(device_id):
    """Create and register an IoT device."""
    # Create thing
    thing = iot.create_thing(
        thingName=device_id,
        thingTypeName='TemperatureSensor',
        attributes={
            'firmware_version': '2.1.0',
            'location': 'factory-floor-a'
        }
    )
    
    # Create certificate
    cert = iot.create_keys_and_certificate(setAsActive=True)
    
    # Attach policy
    iot.attach_policy(
        policyName='IoTPublishPolicy',
        target=cert['certificateArn']
    )
    
    # Attach certificate to thing
    iot.attach_thing_principal(
        thingName=device_id,
        principal=cert['certificateArn']
    )
    
    print(f"Device {device_id} provisioned")
    print(f"Certificate ARN: {cert['certificateArn']}")
    
    return {
        'certificate_pem': cert['certificatePem'],
        'private_key': cert['keyPair']['PrivateKey'],
        'endpoint': iot.describe_endpoint(endpointType='iot:Data-ATS')['endpointAddress']
    }

# Deprovision — important for device lifecycle
def decommission_device(device_id, cert_arn):
    iot.update_certificate(
        certificateId=cert_arn.split('/')[-1],
        newStatus='INACTIVE'
    )
    iot.detach_thing_principal(
        thingName=device_id,
        principal=cert_arn
    )
    iot.delete_certificate(certificateId=cert_arn.split('/')[-1])
    iot.delete_thing(thingName=device_id)
    print(f"Device {device_id} decommissioned")

-- AWS IoT SQL Rule
SELECT 
  device_id,
  temperature,
  humidity,
  timestamp()
FROM 'sensors/+/telemetry'
WHERE temperature > 30.0

# Rule action — Lambda function
import json
import boto3

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table('TemperatureAlerts')

def lambda_handler(event, context):
    # Parse incoming IoT message
    for record in event['records']:
        payload = json.loads(record['data'])
        
        item = {
            'device_id': payload['device_id'],
            'timestamp': int(time.time()),
            'temperature': payload['temperature'],
            'humidity': payload.get('humidity'),
            'threshold_exceeded': True
        }
        
        table.put_item(Item=item)
        
        print(f"Alert saved: {item['device_id']} at {item['temperature']}°C")
    
    return {'statusCode': 200}

# Azure IoT Hub device SDK
from azure.iot.device import IoTHubDeviceClient, Message
import json
import asyncio

connection_string = "HostName=myhub.azure-devices.net;DeviceId=sensor-01;SharedAccessKey=..."

async def main():
    client = IoTHubDeviceClient.create_from_connection_string(connection_string)
    await client.connect()
    
    # Device twin reported properties
    reported_properties = {
        'firmware': '2.1.0',
        'battery_level': 85
    }
    await client.patch_twin_reported_properties(reported_properties)
    
    # Send telemetry
    while True:
        telemetry = {
            'device_id': 'sensor-01',
            'temperature': 22.5,
            'humidity': 55,
            'timestamp': time.time()
        }
        
        msg = Message(json.dumps(telemetry))
        msg.content_encoding = 'utf-8'
        msg.content_type = 'application/json'
        
        await client.send_message(msg)
        print(f"Sent: {telemetry}")
        
        # Handle direct method calls
        client.on_method_request_received = handle_method
        
        await asyncio.sleep(60)
    
    await client.disconnect()

def handle_method(method_request):
    if method_request.name == "reboot":
        print("Rebooting device...")
        return {"result": "rebooting"}

# Google Cloud Pub/Sub for IoT
from google.cloud import pubsub_v1
import json

project_id = "my-iot-project"
topic_id = "sensor-telemetry"

publisher = pubsub_v1.PublisherClient()
topic_path = publisher.topic_path(project_id, topic_id)

def publish_sensor_data(device_id, temperature, humidity):
    data = json.dumps({
        'device_id': device_id,
        'temperature': temperature,
        'humidity': humidity,
        'timestamp': int(time.time())
    }).encode('utf-8')
    
    # Future — non-blocking publish
    future = publisher.publish(
        topic_path,
        data,
        device_id=device_id,
        source='iot-sensor'
    )
    
    message_id = future.result()
    print(f"Published: {message_id}")
    return message_id

# Subscriber with Dataflow-style processing
def telemetry_callback(message):
    data = json.loads(message.data.decode('utf-8'))
    print(f"Received from {data['device_id']}: {data['temperature']}°C")
    
    if data['temperature'] > 35:
        # Route to alert topic
        alert_topic = publisher.topic_path(project_id, "temperature-alerts")
        publisher.publish(alert_topic, message.data)
    
    message.ack()

import click
import boto3
from azure.iot.hub import IoTHubRegistryManager

@click.group()
def cli():
    pass

@cli.command()
@click.option('--platform', default='aws')
@click.option('--device-id', required=True)
def provision(platform, device_id):
    if platform == 'aws':
        provision_aws(device_id)
    elif platform == 'azure':
        provision_azure(device_id)

@cli.command()
@click.option('--platform', default='aws')
@click.option('--device-id', required=True)
def decommission(platform, device_id):
    if platform == 'aws':
        decommission_aws(device_id)
    elif platform == 'azure':
        decommission_azure(device_id)

@cli.command()
@click.option('--platform', default='aws')
def list_devices(platform):
    if platform == 'aws':
        iot = boto3.client('iot')
        things = iot.list_things()
        for thing in things['things']:
            print(f"{thing['thingName']} - {thing['thingTypeName']}")