前言：邊緣計算為什麼成為工業4.0的必選項

傳統雲端集中式架構面臨著三大瓶頸：延遲成本、頻寬浪費、隱私風險。當一家台灣半導體製造廠每天產生 50TB 的感測器數據時，將所有數據上傳至遠端雲端不僅成本驚人（月均 100~300 萬台幣頻寬費），更重要的是 毫秒級別的延遲會導致瑕疵漏檢、設備停機成本急增。

邊緣計算透過在設備端、網路邊界進行即時決策與分析，實現了 延遲減少 90%、頻寬節省 70%、決策速度提升 10 倍 的實際效果。根據 Gartner 2024 年市場調研，全球邊緣計算市場已達 380 億美元，年增速 22.3%。

然而，邊緣計算硬體選型絕非「越高端越好」。我們每年服務超過 50 家台灣工業客戶，其中 68% 的專案因為硬體選型不當而失敗：過度配置導致成本浪費 40%~60%，欠配則引發實時性不足、模型推論卡頓。

本指南聚焦於 決策框架與量化標準，幫助工程師、設施管理者、採購決策者在眾多邊緣計算硬體平臺中做出最優選擇。內容涵蓋：

• 邊緣計算架構完整解析 — 從雲邊協同到本地推論的分層設計
• 硬體選型核心 10 大指標 — 超越 CPU 頻率，理解真實計算場景
• 感測器與硬體整合方案 — 昶特ATLANTIS 工業級監測方案實例
• 真實案例研究與 ROI 計算 — 化工廠、食品加工、紡織製造的實測數據
• 20 個核心 FAQ 與實作範例 — 包含 Python、JavaScript 範例程式碼

第 1 章：邊緣計算架構完整解析——從雲邊協同到本地推論

1.1 邊緣計算分層架構圖解

現代工業應用採用 「霧計算三層模型」，而非單純的「雲或邊」二元對立：

1.2 感測器數據流的現實世界

讓我們從一個真實場景開始：一間年產 10,000 台的電子產品組裝廠。

• 感測器數量： 80 個壓力、溫度、濕度、振動感測器分布於 12 個生產線
• 採樣頻率： 100Hz（每秒 100 次）～ 1kHz（1,000 次），取決於設備
• 日均資料量： 未過濾狀態下 50GB～100GB
• 關鍵事件數量： 日均 50～200 個需要毫秒級反應的異常

1.3 昶特ATLANTIS在邊緣架構中的位置

作為工業感測器方案的領導者，昶特已累積 31 年的製造經驗。在邊緣計算時代，我們的產品無縫整合至三層架構：

• 設備層： ATLANTIS 高精度壓力/溫度感測器（-40～+200°C、0～600 bar） 直連 PLC/微控制器，精度 0.5% FS
• 邊界層： 支援 Modbus RTU、Profibus、Ethernet/IP 等工業協議的訊號轉換器，實現感測器→邊界伺服器的 10ms 級延遲
• 融合層： 推薦搭配 NVIDIA Jetson Orin Nano（8TFLOPS AI 推論）或 Intel NUC i7（低成本方案），實現本地 ML 推論

圖1：ATLANTIS 工業級壓力感測器 — 適配邊緣計算各層級應用

第 2 章：邊緣計算硬體選型核心 10 大指標

2.1 超越 CPU 頻率的真實計算能力評估

許多工程師犯的第一個錯誤是 只看 CPU 頻率（GHz）或核心數量。這導致許多採購決策失誤：要麼買了價格是成本 2～3 倍的高端硬體，要麼買了便宜貨最後卡頓連連。

真實的硬體評估應基於以下 10 大指標。為簡化起見，我們為常見的邊緣計算平臺製作了對比表：

2.2 選型決策矩陣

根據上表，我們可以繪製一份實用的選型決策樹：

第 3 章：昶特ATLANTIS工業感測器與邊緣硬體整合方案

3.1 ATLANTIS 產品在邊緣計算中的角色定位

邊緣計算的成功與否，70% 取決於感測器數據的品質。即便您購買了全球最快的邊界伺服器，若感測器精度不足、漂移率高、可靠性差，再高端的硬體也是「垃圾進、垃圾出」。

昶特ATLANTIS已服務超過 1,200 家台灣製造業客戶，其中 340 家已升級至邊緣計算架構。我們的感測器產品線特別為邊界應用優化：

• 超高精度： 精度等級 0.5%~0.1% FS（行業標準 ±1%~2%）
• 低漂移率： 年度零漂移率 < 0.3%（連續 3 年無需重新校正）
• 寬工作溫度： -40~+200°C，覆蓋所有工業場景（冷庫到高溫製程）
• 工業通訊協議： Modbus RTU / TCP、Profibus DP、Ethernet/IP 原生支援
• 30 年可靠性數據： MTBF > 100,000 小時

圖2：ATLANTIS 數位壓力變送器 — 原生支援 Modbus TCP/IP，邊緣計算友善設計

3.2 推薦整合方案：ATLANTIS + 邊界伺服器的標準組態

3.3 典型場景：大型 HVAC 系統的完整部署

一個 15 層辦公大樓的 HVAC 系統需要監測：

• 5 個區域的進出口溫度（10 個溫度感測器）
• 8 個關鍵管線節點的壓力（8 個壓力感測器）
• 3 個冷卻塔的振動監測（3 個加速度感測器）
• 即時異常檢測與自動化預警

第 4 章：真實案例研究與 ROI 計算

4.1 案例一：化工廠反應釜監測系統升級

案例背景：

• 規模：日均產能 500 噸、全年營收 2.5 億台幣
• 設備：6 個 500L 反應釜、4 個儲存罐
• 痛點：故障停機導致日均損失 NT$80,000~120,000

遭遇的問題：

• 釜內溫度與壓力無即時監測，靠操作員人工巡檢（間隔 2 小時）
• 設備異常時發現延遲 30~120 分鐘，導致產品報廢風險
• 年度停機成本 NT$20,000,000～30,000,000（200~300 次停機）
• 人工檢測誤差率 8%~12%

投資回報分析：

技術細節：

• 部署 12 個 ATLANTIS 壓力感測器（精度 0.25% FS）+ 12 個溫度感測器
• 邊界層採用 Intel NUC i7 + 機器學習異常檢測模型
• 檢測模型為隔離森林（Isolation Forest），訓練樣本 6 個月歷史數據
• 異常偵測準確率 94%，誤報率 < 2%

4.2 案例二：食品加工廠冷鏈監測系統

案例背景：

• 規模：日均冷藏容量 800 噸、全年營收 3.8 億台幣
• 設備：25 個冷藏室、4 個冷凍塔、15 台冷藏運輸車
• 痛點：溫度失控導致產品報廢，年度損失 NT$8,000,000～12,000,000

遭遇的問題：

• 傳統指針式溫度計無法遠端監測，發現溫度異常時產品已報廢
• 法規要求溫度記錄必須追溯，人工紙質記錄無法承受審查
• 冷鏈運輸車無實時追蹤，產品品質無保障
• 年度產品報廢率 3.2%（正常應為 0.5%）

實施方案：

• 冷藏室層： 每間裝置 2 個 ATLANTIS 溫度感測器 + 1 個濕度感測器（共 75 台）
• 運輸車層： 每輛車配置 1 個 IoT 溫度記錄儀 + 4G 連接模組
• 邊界層： 區域冷藏中心部署 1 台企業級邊界伺服器（Intel Xeon），統一收集與分析
• 上層： 資料彙聚至雲端，提供法規追溯報告與分析儀表板

投資回報分析：

第 5 章：20 個核心 FAQ — 邊緣計算硬體選型完全解答

所需最小計算能力 = (感測器數 × 採樣率 × 資料位寬) / 處理窗口

例如：
- 100 個感測器，每個 100Hz（100 樣本/秒）
- 資料位寬 32 bits（4 bytes）
- 要求 < 100ms 處理窗口

所需能力 = (100 × 100 × 4) / 0.1 = 400 KB/s = 3.2 Mbps

Intel NUC i7 的記憶體頻寬約 21 GB/s，可輕鬆處理。但若有 AI 推論任務，還需評估 TFLOPS 是否足夠。

第 6 章：邊緣計算實作範例 — AWS IoT 整合與邊界部署

6.1 Python 範例：AWS IoT Greengrass 邊界推論（含 ATLANTIS Modbus 讀取）

本範例展示如何在 AWS IoT Greengrass 運行時環境中，讀取 ATLANTIS Modbus 感測器數據，執行本地異常檢測，並將結果發送至 AWS IoT Core。

前置要求：

• AWS IoT Greengrass 核心裝置已安裝並授權（AWS 帳戶）
• ATLANTIS Modbus RTU 感測器已連接至邊界伺服器
• Python 3.8+ 與必要的 AWS SDK 已安裝

# greengrasss_anomaly_detector.py
import json
import logging
import time
from datetime import datetime
from collections import deque
import numpy as np
from sklearn.ensemble import IsolationForest
import pymodbus
from pymodbus.client.sync import ModbusSerialClient as ModbusClient
import awsiot.greengrasscore.deployment_client as deployment_client
from awscrt import mqtt

# 配置日誌
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class ATLANTISModbusReader:
    """讀取 ATLANTIS Modbus RTU 感測器"""
    
    def __init__(self, port='/dev/ttyUSB0', baudrate=9600, device_id=1):
        self.client = ModbusClient(
            method='rtu',
            port=port,
            baudrate=baudrate,
            timeout=1,
            stopbits=1,
            bytesize=8,
            parity='N'
        )
        self.device_id = device_id
        self.client.connect()
        logger.info(f"Modbus 連接成功: {port}")
    
    def read_temperature(self, register=100):
        """讀取溫度值（ATLANTIS 溫度感測器）"""
        try:
            result = self.client.read_holding_registers(register, 2, unit=self.device_id)
            if result.isError():
                logger.error(f"Modbus 讀取錯誤: {result}")
                return None
            # ATLANTIS 格式：16-bit 整數 + 16-bit 小數部分
            temp_value = (result.registers[0] + result.registers[1] / 100) / 10
            return round(temp_value, 2)
        except Exception as e:
            logger.error(f"溫度讀取異常: {e}")
            return None
    
    def read_pressure(self, register=102):
        """讀取壓力值（ATLANTIS 壓力變送器）"""
        try:
            result = self.client.read_holding_registers(register, 2, unit=self.device_id)
            if result.isError():
                logger.error(f"Modbus 讀取錯誤: {result}")
                return None
            pressure_value = (result.registers[0] + result.registers[1] / 100) / 10
            return round(pressure_value, 2)
        except Exception as e:
            logger.error(f"壓力讀取異常: {e}")
            return None
    
    def disconnect(self):
        self.client.close()

class EdgeAnomalyDetector:
    """邊界 AI 異常檢測"""
    
    def __init__(self, window_size=100, contamination=0.02):
        self.window_size = window_size
        self.data_buffer = deque(maxlen=window_size)
        self.model = IsolationForest(
            contamination=contamination,
            random_state=42,
            n_estimators=50
        )
        self.is_trained = False
    
    def add_sample(self, sensor_data):
        sample = {
            'timestamp': datetime.now().isoformat(),
            **sensor_data
        }
        self.data_buffer.append(sample)
        
        if len(self.data_buffer) == self.window_size and not self.is_trained:
            self.train_model()
    
    def train_model(self):
        """訓練異常檢測模型"""
        data_list = list(self.data_buffer)
        features = np.array([
            [d['temperature'], d['pressure']] for d in data_list
        ])
        self.model.fit(features)
        self.is_trained = True
        logger.info("邊界 AI 異常檢測模型已訓練")
    
    def detect_anomaly(self, sensor_data):
        """檢測異常"""
        if not self.is_trained:
            return {'is_anomaly': False, 'score': 0.0}
        
        features = np.array([
            [sensor_data['temperature'], sensor_data['pressure']]
        ])
        
        prediction = self.model.predict(features)[0]
        score = self.model.score_samples(features)[0]
        
        is_anomaly = (prediction == -1)
        
        if is_anomaly:
            logger.warning(f"⚠️ 異常檢測: {sensor_data} | 分數: {score:.3f}")
        
        return {
            'is_anomaly': is_anomaly,
            'score': float(score),
            'temperature': sensor_data['temperature'],
            'pressure': sensor_data['pressure']
        }

class AWSIoTPublisher:
    """發佈至 AWS IoT Core"""
    
    def __init__(self, client_id, endpoint, cert_path, key_path, ca_path):
        self.client_id = client_id
        self.mqtt_client = mqtt.Client(
            bootstrap=mqtt.AwsSignedAuth(
                credentials=None,
                region="ap-southeast-1"
            ),
            client_id=client_id,
            host_name=endpoint
        )
        self.connected = False
    
    def on_connection_success(self, unused_arg):
        logger.info("已連接至 AWS IoT Core")
        self.connected = True
    
    def on_connection_failure(self, connection, callback_context):
        logger.error("AWS IoT 連接失敗")
        self.connected = False
    
    def publish_anomaly(self, anomaly_data):
        """發佈異常檢測結果至 IoT Topic"""
        if self.connected:
            topic = "atlantis/edge/anomalies"
            payload = json.dumps(anomaly_data)
            self.mqtt_client.publish(
                topic=topic,
                payload=payload,
                qos=mqtt.QoS.AT_LEAST_ONCE
            )
            logger.info(f"發佈至 {topic}: {payload}")

# 主程式
def lambda_handler(event, context):
    """AWS Lambda 入口點（可用於定時觸發）"""
    
    # 初始化
    modbus_reader = ATLANTISModbusReader(port='/dev/ttyUSB0')
    detector = EdgeAnomalyDetector(window_size=100)
    
    # 採樣循環（模擬 10 秒連續採樣）
    for i in range(100):
        temp = modbus_reader.read_temperature()
        pressure = modbus_reader.read_pressure()
        
        if temp is not None and pressure is not None:
            sensor_data = {
                'temperature': temp,
                'pressure': pressure,
                'timestamp': datetime.now().isoformat()
            }
            
            detector.add_sample(sensor_data)
            
            # 訓練後進行檢測
            if detector.is_trained and i >= 100:
                result = detector.detect_anomaly(sensor_data)
                print(f"[{i}] 異常: {result['is_anomaly']}, 分數: {result['score']:.3f}")
        
        time.sleep(0.1)
    
    modbus_reader.disconnect()
    
    return {
        'statusCode': 200,
        'body': json.dumps('邊界異常檢測完成')
    }

if __name__ == "__main__":
    lambda_handler(None, None)

6.2 JavaScript 範例：AWS IoT Core MQTT 發佈（Node.js）

本範例展示如何使用 AWS IoT Device SDK for JavaScript，將邊界伺服器的 ATLANTIS 感測器數據發佈至 AWS IoT Core。

// aws-iot-publisher.js
const awsIot = require('aws-iot-device-sdk');
const Modbus = require('modbus-serial');
const fs = require('fs');
const path = require('path');

// AWS IoT 連接配置
const deviceConfig = {
    keyPath: '/path/to/private.key',
    certPath: '/path/to/certificate.pem',
    caPath: '/path/to/AmazonRootCA1.pem',
    clientId: 'atlantis-edge-device-001',
    host: 'xxxxxx-ats.iot.ap-southeast-1.amazonaws.com',
    region: 'ap-southeast-1'
};

// ATLANTIS Modbus RTU 配置
const modbusClient = new Modbus();
const MODBUS_CONFIG = {
    port: '/dev/ttyUSB0',
    baudRate: 9600,
    dataBits: 8,
    stopBits: 1,
    parity: 'none'
};

// 初始化 AWS IoT Device
const thingShadow = awsIot.thingShadow({
    keyPath: deviceConfig.keyPath,
    certPath: deviceConfig.certPath,
    caPath: deviceConfig.caPath,
    clientId: deviceConfig.clientId,
    host: deviceConfig.host
});

let deviceConnected = false;

thingShadow.on('connect', function() {
    console.log('✅ 已連接至 AWS IoT Core');
    deviceConnected = true;
    
    // 訂閱 Thing Shadow 的更新
    thingShadow.subscribe('atlantis-edge-device');
});

thingShadow.on('error', function(error) {
    console.error('❌ AWS IoT 錯誤:', error);
    deviceConnected = false;
});

// 初始化 Modbus
async function initModbus() {
    try {
        await modbusClient.connectRTUBuffered(MODBUS_CONFIG.port, {
            baudRate: MODBUS_CONFIG.baudRate
        });
        console.log('✅ Modbus 連接成功');
    } catch (err) {
        console.error('❌ Modbus 連接失敗:', err);
        setTimeout(initModbus, 5000);
    }
}

// 讀取 ATLANTIS 感測器數據
async function readATLANTISSensors() {
    try {
        modbusClient.setID(1);  // ATLANTIS 設備 ID
        
        // 讀取暫存器 100-103（溫度與壓力）
        const registers = await modbusClient.readHoldingRegisters(100, 4);
        
        const temperature = (registers[0] + registers[1] / 100) / 10;
        const pressure = (registers[2] + registers[3] / 100) / 10;
        
        return {
            temperature: parseFloat(temperature.toFixed(2)),
            pressure: parseFloat(pressure.toFixed(2)),
            timestamp: new Date().toISOString(),
            deviceId: deviceConfig.clientId
        };
    } catch (err) {
        console.error('❌ 感測器讀取錯誤:', err);
        return null;
    }
}

// 發佈至 AWS IoT Core（使用 MQTT Topic）
function publishToAWSIoT(sensorData) {
    if (!deviceConnected) {
        console.warn('未連接至 AWS IoT，暫存數據本地快取');
        return;
    }
    
    const topic = 'atlantis/sensors/data';
    const payload = JSON.stringify(sensorData);
    
    // 使用 Thing Shadow 更新（持久化）
    const stateObject = {
        state: {
            reported: {
                ...sensorData,
                lastUpdate: new Date().toISOString()
            }
        }
    };
    
    thingShadow.update('atlantis-edge-device', stateObject);
    
    console.log(`📤 發佈至 ${topic}:`, payload);
}

// 檢測異常（簡化版）
function detectAnomalies(sensorData) {
    const anomalies = [];
    
    if (sensorData.temperature < -10 || sensorData.temperature > 100) {
        anomalies.push({
            type: 'temperature',
            value: sensorData.temperature,
            severity: 'high',
            message: `溫度異常: ${sensorData.temperature}°C`
        });
    }
    
    if (sensorData.pressure < 0 || sensorData.pressure > 10) {
        anomalies.push({
            type: 'pressure',
            value: sensorData.pressure,
            severity: 'high',
            message: `壓力異常: ${sensorData.pressure} bar`
        });
    }
    
    return anomalies;
}

// 定時採樣與發佈（每秒一次）
setInterval(async () => {
    const sensorData = await readATLANTISSensors();
    
    if (sensorData) {
        // 檢測異常
        const anomalies = detectAnomalies(sensorData);
        
        const payload = {
            ...sensorData,
            anomalies: anomalies.length > 0 ? anomalies : null
        };
        
        // 發佈至 AWS IoT
        publishToAWSIoT(payload);
        
        // 異常告警
        if (anomalies.length > 0) {
            console.log('⚠️ 異常警報:', anomalies);
            
            // 發佈至專用異常 Topic（供 Lambda 訂閱）
            thingShadow.update('atlantis-edge-device', {
                state: {
                    reported: {
                        lastAnomaly: anomalies[0],
                        anomalyCount: anomalies.length
                    }
                }
            });
        }
    }
}, 1000);

// 優雅關閉
process.on('SIGINT', () => {
    console.log('\n正在關閉...');
    modbusClient.close();
    thingShadow.end();
    process.exit(0);
});

// 啟動
initModbus();

6.3 AWS Lambda 函數：雲端異常分析與告警

本範例展示如何在 AWS Lambda 中訂閱 IoT 主題，接收邊界層的感測器數據，進行進階分析，並觸發 SNS 告警。

// lambda_anomaly_analyzer.py
import json
import boto3
import logging
from datetime import datetime, timedelta
from decimal import Decimal

logger = logging.getLogger()
logger.setLevel(logging.INFO)

# AWS 服務客戶端
iot_data = boto3.client('iot-data', region_name='ap-southeast-1')
dynamodb = boto3.resource('dynamodb', region_name='ap-southeast-1')
sns = boto3.client('sns', region_name='ap-southeast-1')
cloudwatch = boto3.client('cloudwatch', region_name='ap-southeast-1')

# DynamoDB 表配置
TABLE_NAME = 'atlantis-sensor-data'
SNS_TOPIC_ARN = 'arn:aws:sns:ap-southeast-1:XXXXXX:anomaly-alerts'

def lambda_handler(event, context):
    """
    Lambda 入口點：訂閱 MQTT Topic 並處理異常
    觸發來源：AWS IoT Rule Engine (SQL Topic Filters)
    """
    
    try:
        # 解析 IoT 核心裝置發送的數據
        sensor_data = json.loads(json.dumps(event, default=str))
        
        logger.info(f"收到感測器數據: {sensor_data}")
        
        # 提取數據
        device_id = sensor_data.get('deviceId', 'unknown')
        temperature = float(sensor_data.get('temperature', 0))
        pressure = float(sensor_data.get('pressure', 0))
        timestamp = sensor_data.get('timestamp', datetime.now().isoformat())
        
        # 存儲至 DynamoDB
        store_sensor_data(device_id, temperature, pressure, timestamp)
        
        # 檢測異常
        anomalies = sensor_data.get('anomalies', [])
        
        if anomalies:
            logger.warning(f"偵測到異常: {anomalies}")
            
            # 發送 SNS 告警
            send_anomaly_alert(device_id, temperature, pressure, anomalies)
            
            # 發佈 CloudWatch 指標
            publish_cloudwatch_metric(device_id, len(anomalies))
        
        # 檢查是否需要進階分析（例如趨勢分析）
        analyze_trend(device_id, temperature, pressure)
        
        return {
            'statusCode': 200,
            'body': json.dumps({
                'message': '異常分析完成',
                'device_id': device_id,
                'anomalies_detected': len(anomalies)
            })
        }
    
    except Exception as e:
        logger.error(f"Lambda 執行錯誤: {str(e)}")
        return {
            'statusCode': 500,
            'body': json.dumps({'error': str(e)})
        }

def store_sensor_data(device_id, temperature, pressure, timestamp):
    """存儲至 DynamoDB"""
    try:
        table = dynamodb.Table(TABLE_NAME)
        
        table.put_item(
            Item={
                'device_id': device_id,
                'timestamp': timestamp,
                'temperature': Decimal(str(temperature)),
                'pressure': Decimal(str(pressure)),
                'ttl': int((datetime.now() + timedelta(days=30)).timestamp())  # 30天後自動過期
            }
        )
        
        logger.info(f"數據已存儲: {device_id} @ {timestamp}")
    
    except Exception as e:
        logger.error(f"DynamoDB 存儲失敗: {str(e)}")

def send_anomaly_alert(device_id, temperature, pressure, anomalies):
    """發送 SNS 告警"""
    try:
        subject = f"⚠️ ATLANTIS 感測器異常告警 - {device_id}"
        
        message = f"""
        設備 ID: {device_id}
        時間: {datetime.now().isoformat()}
        
        異常詳情:
        - 溫度: {temperature}°C
        - 壓力: {pressure} bar
        
        檢測異常:
        {json.dumps(anomalies, indent=2, ensure_ascii=False)}
        
        請立即檢查設備狀態。
        """
        
        sns.publish(
            TopicArn=SNS_TOPIC_ARN,
            Subject=subject,
            Message=message
        )
        
        logger.info(f"告警已發送至 SNS")
    
    except Exception as e:
        logger.error(f"SNS 告警發送失敗: {str(e)}")

def publish_cloudwatch_metric(device_id, anomaly_count):
    """發佈 CloudWatch 自訂指標"""
    try:
        cloudwatch.put_metric_data(
            Namespace='ATLANTIS/EdgeComputing',
            MetricData=[
                {
                    'MetricName': 'AnomalyCount',
                    'Value': anomaly_count,
                    'Unit': 'Count',
                    'Dimensions': [
                        {
                            'Name': 'DeviceID',
                            'Value': device_id
                        }
                    ]
                }
            ]
        )
        
        logger.info(f"CloudWatch 指標已發佈")
    
    except Exception as e:
        logger.error(f"CloudWatch 發佈失敗: {str(e)}")

def analyze_trend(device_id, temperature, pressure):
    """進階趨勢分析（可選）"""
    try:
        table = dynamodb.Table(TABLE_NAME)
        
        # 查詢過去 1 小時的數據
        one_hour_ago = (datetime.now() - timedelta(hours=1)).isoformat()
        
        response = table.query(
            KeyConditionExpression='device_id = :device_id AND #ts > :timestamp',
            ExpressionAttributeNames={'#ts': 'timestamp'},
            ExpressionAttributeValues={
                ':device_id': device_id,
                ':timestamp': one_hour_ago
            },
            Limit=60
        )
        
        if response['Items']:
            temps = [float(item['temperature']) for item in response['Items']]
            avg_temp = sum(temps) / len(temps)
            temp_variance = sum((t - avg_temp) ** 2 for t in temps) / len(temps)
            
            logger.info(f"溫度趨勢 - 平均: {avg_temp:.2f}°C, 方差: {temp_variance:.2f}")
    
    except Exception as e:
        logger.warning(f"趨勢分析失敗: {str(e)}")

6.4 CloudFormation 部署模板（完整基礎設施即程式碼）

本範例展示如何使用 AWS CloudFormation 一鍵部署完整的 AWS IoT 邊界計算基礎設施。

# cloudformation-iot-edge-stack.yaml
AWSTemplateFormatVersion: '2010-09-09'
Description: 'ATLANTIS 邊緣計算 AWS IoT 完整部署方案'

Parameters:
  DeviceThingName:
    Type: String
    Default: atlantis-edge-device-001
    Description: AWS IoT Thing 名稱
  
  SNSEmailEndpoint:
    Type: String
    Description: 接收告警的電子郵件地址

Resources:
  # === AWS IoT Thing ===
  ATLANTISIoTThing:
    Type: AWS::IoT::Thing
    Properties:
      ThingName: !Ref DeviceThingName

  # === DynamoDB 表 ===
  SensorDataTable:
    Type: AWS::DynamoDB::Table
    Properties:
      TableName: atlantis-sensor-data
      AttributeDefinitions:
        - AttributeName: device_id
          AttributeType: S
        - AttributeName: timestamp
          AttributeType: S
      KeySchema:
        - AttributeName: device_id
          KeyType: HASH
        - AttributeName: timestamp
          KeyType: RANGE
      BillingMode: PAY_PER_REQUEST
      TimeToLiveSpecification:
        AttributeName: ttl
        Enabled: true

  # === SNS 告警主題 ===
  AnomalyAlertTopic:
    Type: AWS::SNS::Topic
    Properties:
      TopicName: atlantis-anomaly-alerts
      DisplayName: ATLANTIS 異常告警

  AnomalyAlertSubscription:
    Type: AWS::SNS::Subscription
    Properties:
      TopicArn: !Ref AnomalyAlertTopic
      Protocol: email
      Endpoint: !Ref SNSEmailEndpoint

  # === Lambda 執行角色 ===
  LambdaExecutionRole:
    Type: AWS::IAM::Role
    Properties:
      AssumeRolePolicyDocument:
        Version: '2012-10-17'
        Statement:
          - Effect: Allow
            Principal:
              Service: lambda.amazonaws.com
            Action: sts:AssumeRole
      ManagedPolicyArns:
        - arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
      Policies:
        - PolicyName: DynamoDBAccess
          PolicyDocument:
            Version: '2012-10-17'
            Statement:
              - Effect: Allow
                Action:
                  - dynamodb:PutItem
                  - dynamodb:Query
                Resource: !GetAtt SensorDataTable.Arn
        - PolicyName: SNSPublish
          PolicyDocument:
            Version: '2012-10-17'
            Statement:
              - Effect: Allow
                Action: sns:Publish
                Resource: !Ref AnomalyAlertTopic
        - PolicyName: CloudWatchMetrics
          PolicyDocument:
            Version: '2012-10-17'
            Statement:
              - Effect: Allow
                Action: cloudwatch:PutMetricData
                Resource: '*'

  # === Lambda 函數 ===
  AnomalyAnalyzerFunction:
    Type: AWS::Lambda::Function
    Properties:
      FunctionName: atlantis-anomaly-analyzer
      Runtime: python3.9
      Role: !GetAtt LambdaExecutionRole.Arn
      Handler: index.lambda_handler
      Environment:
        Variables:
          SNS_TOPIC_ARN: !Ref AnomalyAlertTopic
          DYNAMODB_TABLE: !Ref SensorDataTable
      Code:
        ZipFile: |
          import json
          import boto3
          import os
          from datetime import datetime
          
          sns = boto3.client('sns')
          
          def lambda_handler(event, context):
              print(f"收到事件: {json.dumps(event)}")
              
              # 簡化版本，完整程式碼參見 6.3 節
              return {
                  'statusCode': 200,
                  'body': json.dumps('分析完成')
              }

  # === IoT Rule (自動觸發 Lambda) ===
  IoTRuleForAnomalyDetection:
    Type: AWS::IoT::TopicRule
    Properties:
      TopicRulePayload:
        RuleDisabled: false
        Sql: 'SELECT * FROM "atlantis/sensors/data" WHERE temperature > 80 OR pressure > 8'
        Actions:
          - Lambda:
              FunctionArn: !GetAtt AnomalyAnalyzerFunction.Arn

  # === Lambda 權限（允許 IoT 調用） ===
  IoTLambdaPermission:
    Type: AWS::Lambda::Permission
    Properties:
      FunctionName: !Ref AnomalyAnalyzerFunction
      Action: lambda:InvokeFunction
      Principal: iot.amazonaws.com
      SourceArn: !Sub 'arn:aws:iot:${AWS::Region}:${AWS::AccountId}:rule/*'

Outputs:
  IoTEndpoint:
    Description: AWS IoT 端點
    Value: !Sub 'xxxxxxxx-ats.iot.${AWS::Region}.amazonaws.com'
  
  DynamoDBTable:
    Description: 感測器數據表
    Value: !Ref SensorDataTable
  
  SNSTopic:
    Description: 異常告警主題
    Value: !Ref AnomalyAlertTopic

6.5 部署指南：從邊界設備到 AWS IoT Cloud

# 步驟 1：建立 AWS 帳戶與 IoT 核心基礎設施
# 登入 AWS 管理控制台 → IoT Core → 一鍵設置（如果首次使用）

# 步驟 2：建立 Thing 與證書
aws iot create-thing --thing-name atlantis-edge-device-001

# 建立憑證（將返回三個檔案）
aws iot create-keys-and-certificate --set-as-active \
  --certificate-pem-outfile cert.pem \
  --public-key-outfile public.key \
  --private-key-outfile private.key

# 獲取 AWS Root CA 憑證
curl https://www.amazontrust.com/repository/AmazonRootCA1.pem -o AmazonRootCA1.pem

# 步驟 3：建立 IoT 政策
cat > iot-policy.json << EOF
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "iot:*",
      "Resource": "*"
    }
  ]
}
EOF

aws iot create-policy --policy-name atlantis-policy --policy-document file://iot-policy.json

# 步驟 4：部署 CloudFormation 堆棧
aws cloudformation create-stack \
  --stack-name atlantis-iot-stack \
  --template-body file://cloudformation-iot-edge-stack.yaml \
  --parameters ParameterKey=SNSEmailEndpoint,ParameterValue=your-email@example.com \
  --capabilities CAPABILITY_NAMED_IAM

# 步驟 5：在邊界伺服器安裝 AWS SDK
pip install awsiotsdk boto3 pymodbus

# 步驟 6：執行 Node.js 發佈器
node aws-iot-publisher.js

# 步驟 7：監測 CloudWatch 日誌
aws logs tail /aws/lambda/atlantis-anomaly-analyzer --follow

# 步驟 8：驗證 DynamoDB 中的數據
aws dynamodb scan --table-name atlantis-sensor-data --region ap-southeast-1

結論：邊緣計算不是未來，是現在

邊緣計算已不是技術前沿的概念，而是 工業製造的必選項。過去 3 年間，台灣工業客戶的邊緣計算採用率從 12% 增長至 58%，預計 2027 年將突破 80%。

關鍵統計：

• 成本節省： 導入邊緣計算的客戶年度生產成本平均下降 8%~15%
• 故障率下降： 設備故障停機時間縮短 85%~95%
• 決策速度： 從「小時級」決策升級至「毫秒級」自動化
• 投資回報： 平均 2~4 個月回本，3 年累積 ROI > 300%

然而，成功的邊緣計算部署不在技術，而在決策框架。選錯硬體 30 秒，費時 30 個月。

本指南提供的 10 大選型指標、決策矩陣、真實案例與程式碼範例，是我們 30 年工業經驗的結晶。無論您是製造業工程師、IT 決策者或採購專員，都能透過本指南做出最優選擇。