ESP32 with AWS IoT -4-

👨‍💻 Connecting AWS with ESP32: Create an IoT Lamp

이번 글은 🔗 Workshop:ESP32 with AWS IoT 의 내용을 직접 실습한 뒤 재 포스팅 한 내용입니다.

1. 시스템 개요

이번 실습에서는 Web을 통해 ESP32를 제어하는 실습에 대해 진행할 예정이다. 이번 실습에서는 Relay Module을 이용한 Lamp를 만들예정이다. 이전 4발 스위치를 이용해 데이터를 전송했던 🔗 Create an AWS IoT Button 실습과 큰 차이점이 두 가지가 있다.

1. 주 데이터의 흐름

   AWS IoT Button 실습때의 주된 흐름은 ESP32 에서 발생한 데이터(버튼 눌렸다는 메시지 + 눌린 수)가 AWS의 MQTT Broker에게 전달되 Lambda를 트리거링 하는 방식으로써 간단히 설명해 ESP32 to AWS 라고 한다면 오늘의 실습은 AWS to ESP32 이다.

2. 시스템 컴포넌트의 수

   저번 실습에는 시스템에 AWS Lambda 를 이용해 간단한 로그를 출력했다면, 이번에는 AWS Lambda, AWS API Gatyeway, AWS 3S(Simple Stroage Service) 와 AWS Device Shadow 가 시스템의 컴포넌트로 들어간다.

시스템 구성은 위 와 같다. 사용자는 API Gateway를 통해 서버에 접속한뒤, 접속된 서버에서 버튼을 눌러 Lamp를 제어하는 시스템이다.

2. Relay Module

전기 Lamp를 구성하는 요소 중 가장 중요한 요소는 전구 혹은 LED 일 것 이다. 만약 이러한 전구가 220V 60W의 전원을 요구한다면 ESP32로 어떻게 제어할 수 있을까? 가장 손쉬운 방법은 Relay Module을 이용하는 것 이다.

Relay Module은 제어신호(SIG)를 이용해 일반 가정에서 사용하는 간단한 220V 기기를 On/Off 할 수 있다. Relay Module에 VCC와 GND를 각각 5V(3.3V) 와 GND를 연결하고 SIG가 LOW일 때, COM 단자와 NC(Normal Close)가 접지인 상태 즉 연결이 되어 있다. 이때 제어 신호가 HIGH 상태로 바뀌면 COM과 NO(Normal Open)이 연결된다.

2.1 Relay Test

만약 진짜 가정용 콘센트를 사용하는 전구로 무드등을 만들고 싶다면 220V 전구 소켓의 피복을 벗긴뒤 COM과 NO에 연결을 하면 된다. 이번 실습에서는 LED를 전구 대신 사용하는것으로 진행한다.

Relay의 동작테스트를 위해 아래 코드를 업로드해 Relay가 잘 작동 되는지 확인해 보자.

int signalPin = 16;

void setup() {
    Serial.begin(115200);
    delay(2000);
    Serial.println("Lelay Module Test");
    pinMode(signalPin, OUTPUT);
}

void loop() {
    Serial.println("On");
    digitalWrite(signalPin, HIGH); 
    delay(1000); 
    Serial.println("Off");
    digitalWrite(signalPin, LOW); 
    delay(1000); 
}

3. AWS IoT Device Shadow

AWS IoT에는 Device Shadow라는 기능이 있다. AWS IoT Core의 개발자 안내서에 Device Shadow Service의 단락을 읽어보면 다음과 같이 써있다.

The AWS IoT Device Shadow service adds shadows to AWS IoT thing objects. Shadows can make a device’s state available to apps and other services whether the device is connected to AWS IoT or not. AWS IoT thing objects can have multiple named shadows so that your IoT solution has more options for connecting your devices to other apps and services.

출처: AWS IoT Core Developer - Guide Deivce Shadow Service

디바이스의 online/offline에 관계없이 디바이스의 상태를 사용할 수 있게 해주는 서비스라고 적혀있다. 마치 디바이스가 인터넷에 연결유무에 상관없이 제어를 할 수있는 것 처럼 오해할 수도 있지만 잘 읽어보면 디바이스가 온라인이던 오프라인이던 상태를 사용할 수 있게 해주는 서비스라고 적혀있다.

Device Shadow Service를 이용하면 내가 송신한 메시지는 실제 사물에 전달되지 않고 Device Shadow에 전달이 된다. 이렇게 전달 된 메시지는 현재 사물의 상태와 비교하여 차이(델타)를 계산한 후 사물에게 전달되어 진다.

Device Shadow 은 JSON으로 이루어진 문서이며, 이 JSON 문서에 사물의 현재 상태 바뀔상태 두 상태간의 차이를 기술한다. 이렇게 세 섹션은 각각 아래와 같다.

1. Desired: 사용자가 원하는 상태
2. Reported: 사물의 현재 형태
3. Delta: Desired와 Reported간의 차이

3.1 Sample Flow

Sample Flow를 통해 간단한 예시를 들어보자. 처음 Device Shadow의 JSON 문서가 아래와 같이 적혀 있다.

{
  "desired": {
    "status": "on"
  },
  "reported": {
    "status": "on"
  }
}

이제 사용자가 Web 혹은 기타 인터페이스를 통해 사물의 상태를 바꾸려한다. 이번 실습에서는 Web에 있는 버튼을 눌러 Lamp를 키려고 하는 것과 같다. 이러한 desired 상태가 AWS IoT로 전송이 될 것 이다.

{
    "state": {
        "desired": {
            "status": "off"
        }
    }
}

desired 와 reported의 상태 불일치는 두 상태의 차이가 발생하여 delta가 계산된다. delat 상태가되면 그 즉시 자신의 사물에게 다음과 같은 토픽으로 $aws/things/{THING_NAME}/shadow/update/delta (혹은 $aws/things/{THING_NAME}/shadow/{SHADOW_NAME}/update/delta) 아래 메시지를 발행한다.

{
  "version": 463,
  "timestamp": 1571747274,
  "state": {
    "status": "off"
  },
  "metadata": {
    "status": {
      "timestamp": 1571747274
    }
  }
}

이 메시지를 수신한 사물은 그 즉시 desired에 있는 status로 실제 상태(여기서는 Lamp의 소등)를 반영한 뒤 $aws/things/{THING_NAME}/shadow/update (혹은 $aws/things/{THING_NAME}/shadow/{SHADOW_NAME}/update )로 reported를 전송한다.

{
    "state": {
        "reported": {
            "status": "off"
        }
    }
}

reported를 받은 AWS IoT는 이를 반영해 Device Shadow에 Document에 반영한다.

{
  "desired": {
    "status": "off"
  },
  "reported": {
    "status": "off"
  }
}

3.2 Device Shadow 생성

이제 실제 Device Shadow를 생성해 보자. AWS IoT Core로 접속 한 뒤 좌측 패널에서 관리 ➜ 사물 에서 자신이 만들었던 사물(여기서는 ESP32) 을 클릭해보자.

섀도우 생성 을 클릭한 뒤, 이름 없는(클래식) 섀도우를 생성해 보자. 🔗 Workshop:ESP32 with AWS IoT 에서는 클래식과 네임드 섀도우의 구분을 따로 지정하지 않았는데 이게 버전이 올라가서 생긴 차이인지 혹은 원 저자가 일부러 언급을 안한건지 알 수는 없다. 네임드 섀도우를 생성해 살펴보면캡

다음과 같은 토픽차이가 발생한다. 원 저자가 $aws/things/ESP32/shadow 라는 토픽 접두사를 계속 사용한것으로보아 클래식 섀도우를 생성하면 된다.

참고로 $aws는 시스템 혹은 히든 토픽이라고 부른다(MQTT에서 사용하는 와일드 카드는 아님).

Device Shadow를 생성하면 디바이스 섀도우 문서 탭에 들어가면 다음과 같은 초기 상태를 볼 수 있다.

디바이스 섀도우 상태

{
  "state": {
    "desired": {
      "welcome": "aws-iot"
    },
    "reported": {
      "welcome": "aws-iot"
    }
  }
}

디바이스 섀도우 메타데이터

{
  "metadata": {
    "desired": {
      "welcome": {
        "timestamp": 1638861952
      }
    },
    "reported": {
      "welcome": {
        "timestamp": 1638861952
      }
    }
  }
}

4. ESP32 Setting 및 Policy Update

이제 사물에 코드를 업로드한뒤 Device Shadow의 토픽 사용을 위해 Policy를 업데이트 하자. 우선 아래의 코드를 ESP32에 업로드 한다.

/*
  Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  Permission is hereby granted, free of charge, to any person obtaining a copy of this
  software and associated documentation files (the "Software"), to deal in the Software
  without restriction, including without limitation the rights to use, copy, modify,
  merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
  permit persons to whom the Software is furnished to do so.
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
  INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/


#include "secrets.h"
#include <WiFiClientSecure.h>
#include <MQTTClient.h>
#include <ArduinoJson.h>
#include "WiFi.h"

// The MQTT topics that this device should publish/subscribe
#define AWS_IOT_PUBLISH_TOPIC   "$aws/things/ESP32/shadow/update"
#define AWS_IOT_SUBSCRIBE_TOPIC "$aws/things/ESP32/shadow/update/delta"

int msgReceived = 0;
int signalPin = 16;
String rcvdPayload;
char sndPayloadOff[512];
char sndPayloadOn[512];

WiFiClientSecure net = WiFiClientSecure();
MQTTClient client = MQTTClient(256);

void connectAWS()
{
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  Serial.println("");
  Serial.println("###################### Starting Execution ########################");
  Serial.println("Connecting to Wi-Fi");

  while (WiFi.status() != WL_CONNECTED){
    delay(500);
    Serial.print(".");
  }

  // Configure WiFiClientSecure to use the AWS IoT device credentials
  net.setCACert(AWS_CERT_CA);
  net.setCertificate(AWS_CERT_CRT);
  net.setPrivateKey(AWS_CERT_PRIVATE);

  // Connect to the MQTT broker on the AWS endpoint we defined earlier
  client.begin(AWS_IOT_ENDPOINT, 8883, net);

  // Create a message handler
  client.onMessage(messageHandler);

  Serial.println("Connecting to AWS IOT");

  while (!client.connect(THINGNAME)) {
    Serial.print(".");
    delay(100);
  }

  if(!client.connected()){
    Serial.println("AWS IoT Timeout!");
    return;
  }

  // Subscribe to a topic
  client.subscribe(AWS_IOT_SUBSCRIBE_TOPIC);

  Serial.println("AWS IoT Connected!");
}

void messageHandler(String &topic, String &payload) {
  msgReceived = 1;
  rcvdPayload = payload;
}

void setup() {
  Serial.begin(115200);
  pinMode(signalPin, OUTPUT);
  digitalWrite(signalPin, LOW);
  
  sprintf(sndPayloadOn,"{\"state\": { \"reported\": { \"status\": \"on\" } }}");
  sprintf(sndPayloadOff,"{\"state\": { \"reported\": { \"status\": \"off\" } }}");
  
  connectAWS();
  
  Serial.println("Setting Lamp Status to Off");
  client.publish(AWS_IOT_PUBLISH_TOPIC, sndPayloadOff);
  
  Serial.println("##############################################");
}

void loop() {
   if(msgReceived == 1)
    {
//      This code will run whenever a message is received on the SUBSCRIBE_TOPIC_NAME Topic
        delay(100);
        msgReceived = 0;
        Serial.print("Received Message:");
        Serial.println(rcvdPayload);
        StaticJsonDocument<200> sensor_doc;
        DeserializationError error_sensor = deserializeJson(sensor_doc, rcvdPayload);
        const char *sensor = sensor_doc["state"]["status"];
 
        Serial.print("AWS Says:");
        Serial.println(sensor); 
        
        if(strcmp(sensor, "on") == 0)
        {
         Serial.println("IF CONDITION");
         Serial.println("Turning Lamp On");
         digitalWrite(signalPin, HIGH);
         client.publish(AWS_IOT_PUBLISH_TOPIC, sndPayloadOn);
        }
        else 
        {
         Serial.println("ELSE CONDITION");
         Serial.println("Turning Lamp Off");
         digitalWrite(signalPin, LOW);
         client.publish(AWS_IOT_PUBLISH_TOPIC, sndPayloadOff);
        }
      Serial.println("##############################################");
    }
  client.loop();
}

이제 AWS IoT Core에서 좌측 패널에 보안 ➜ 정책 지난 실습 🔗 Connecting AWS with ESP32: Tutorial 에서 생성했던 ESP32 Policy 를 새로 업데이트한다.

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "iot:Connect",
      "Resource": "arn:aws:iot:REGION:ACCOUNT_ID:client/${iot:Connection.Thing.ThingName}"
    },
    {
      "Effect": "Allow",
      "Action": "iot:Publish",
      "Resource": [
        "arn:aws:iot:REGION:ACCOUNT_ID:topic/esp32/pub",
        "arn:aws:iot:REGION:ACCOUNT_ID:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update"
      ]
    },
    {
      "Effect": "Allow",
      "Action": "iot:Subscribe",
      "Resource": [
        "arn:aws:iot:REGION:ACCOUNT_ID:topicfilter/esp32/sub",
        "arn:aws:iot:REGION:ACCOUNT_ID:topicfilter/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update/delta"
      ]
    },
    {
      "Effect": "Allow",
      "Action": "iot:Receive",
      "Resource": [
        "arn:aws:iot:REGION:ACCOUNT_ID:topic/esp32/sub",
        "arn:aws:iot:REGION:ACCOUNT_ID:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update/delta"
      ]
    }
  ]
}

REGION 과 ACCOUNT_ID 를 모르겠으면 정책 ARN 란에 있는 ARN에서 확인하자.

arn:aws:iot:REGION:ACCOUNT_ID:policy/...

${iot:Connection.Thing.ThingName} 우리가 연결하는 사물의 이름이다. 우리가 만든 사물의 이름은 ESP32 이므로 ESP32를 대신 넣어주면 된다.

5. Create Lambda Function

이제 2 종류의 Lambda Function을 만들어야 한다. 하나는 Web에서 버튼을 클릭했을때 API Gateway를 통해 Desired 상태를 전달해주는 Lambda 와 EPS32의 상태를 체크해주는 Lambda 이다. 여기서 boto3 란 라이브러리를 import 하는데 boto3는 python 용 AWS SDK이다.

Shadow Status Check

import json
import boto3
import logging
 
logger = logging.getLogger()
logger.setLevel(logging.INFO)
 
client = boto3.client('iot-data')
 
def lambda_handler(event, context):
    
    # print(json.dumps(event))
    print("Thing Name: " + json.dumps(event['queryStringParameters']['thingname']))
    
    logger.info("Attempting to fetch Shadow State")
    
    THINGNAME=event['queryStringParameters']['thingname']
    if (THINGNAME == ""):
        print("No Thing Name found. Setting Thing Name = ESP32")
        THINGNAME="ESP32"
    
    try:
        response = client.get_thing_shadow(thingName=THINGNAME)
        logger.info("Shadow State Received")
        res = response['payload'].read()
        res_json = json.loads(res)
        print(json.dumps(res_json))
        
        status = res_json['state']['reported']
        
        logger.info("Received From IoT: " + json.dumps(status))
        
        logger.info("\nChanging for website\n")
     
        value = status['status']
        if (value == "on"):
            status['status'] = "It's On"
        else:
            status['status'] = "It's Off"
        
        logger.info("Sending to Website: " + json.dumps(status) + "\n")
        
        return {
            'statusCode': 200,
            "headers": {
                'Access-Control-Allow-Origin':'*',
                'Access-Control-Allow-Headers':'Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token',
                'Access-Control-Allow-Methods':'GET,OPTIONS'
            },
            'body': json.dumps(status)
        }
    except:
        status = {"status": "Device Shadow State Error"}
        return {
            'statusCode': 200,
            "headers": {
                'Access-Control-Allow-Origin':'*',
                'Access-Control-Allow-Headers':'Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token',
                'Access-Control-Allow-Methods':'GET,OPTIONS'
            },
            'body': json.dumps(status)
        }

Shadow Update

import json
import boto3
import logging
 
logger = logging.getLogger()
logger.setLevel(logging.INFO)
 
client = boto3.client('iot-data')
 
def lambda_handler(event, context):
    print(json.dumps(event['body']))
    
    body = event['body']
    body = json.loads(body)
    
    THINGNAME=body['thingname']
    if (THINGNAME == ""):
        print("No Thing Name found. Setting Thing Name = ESP2")
        THINGNAME="ESP32"
    
    if body['action'] == "on":
        payload = json.dumps({'state': { 'desired': { 'status': 'on' } }})
        
        logger.info("Attempting to Update Shadow State to ON")
        response = client.update_thing_shadow(
            thingName=THINGNAME,
            payload=payload
        )
        logger.info("IOT Shadow Updated")
    else:
        payload = json.dumps({'state': { 'desired': { 'status': 'off' } }})
        
        logger.info("Attempting to Update Shadow State to OFF")
        response = client.update_thing_shadow(
            thingName=THINGNAME,
            payload=payload
        )
        logger.info("IOT Shadow Updated")
        
    
    return {
        'statusCode': 200,
        "headers": {
            'Access-Control-Allow-Origin':'*',
            'Access-Control-Allow-Headers':'Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token',
            'Access-Control-Allow-Methods':'GET,OPTIONS'
        },
        'body': json.dumps('Shadow Updated!')
    }

Lambda 생성 방법은 🔗 Create an AWS IoT Button 실습 편을 참고하자. 이제 우리의 Lambda Function이 AWS IoT Data에 접근하기 위해

🔗 AWSIoTDataAccess 에서 정책사용에 Lambda를 넣어 줘야한다. 링크를 타고 들어가도 되며, AWS 관리 콘솔에 로그인한 뒤, AWS 서비스 ➜ 모든 서비스 ➜ IAM에 접속한다(IAM은 모든 서비스 란에 보안, 자격 증명 및 규정 준수 에서 찾을 수 있다). 이제 좌측 패널에 액세스 관리 ➜ 정책 으로 들어가서 AWSIoTDataAcces 정책을 검색한뒤 정책 사용탭에서 연결을 클릭해 방금 만든 Lambda Function 을 등록한다.

6. AWS API Gateway

6.1 API Gateway 란?

API Gateway는 API 서버 앞단에서 모든 API 서버들의 엔드포인트를 단일화 해주는 또 다른 서버입니다. API에 대한 인증과 인가 기능을 가지고 있으며, 메세지의 내용에 따라 어플리케이션 내부에 있는 마이크로서비스로 라우팅하는 역할을 담당합니다.

출처: 이데아텍 솔루션

API Gateway는 사용자가 API를 호출하는 정문이다. AWS에서는 이러한 API를 쉽게 생성 및 배포를 할 수 있으며 이러한 API들은 AWS API Gateway Service에서 관리할 수 있다. 또한 API Gateway Service를 이용해 Lambda를 호출하거나 데이터베이스와의 연동 등 AWS 여러 다른 서비스와 연동할 수 있다.

6.2 Create API Gateway and Integration Lambda

API Gateway 에서 API를 생성한뒤 생성된 API와 Lambda를 연결해 API를 호출할 때 마다 Lambda를 트리거링하도록 연동시켜 보자

AWS 콘솔 서비스에서 API Gateway로 접속한 뒤 좌측 패널 API를 클릭한 뒤 API를 생성하자. 생성할 수 있는 아래 4가지 유형이 있다.

1. HTTP
2. Websocket
3. REST
4. REST(Private)

여기서 HTTP API 혹은 REST API 두 API는 거의 비슷한 일을 할 수 있는데 HTTP API는 단순한 작업 밖에 못하지만 가격면에서 저렴하다. 반면 REST API는 복잡한 작업과 연동이 되지만 가격이 비싸다. 두 API 모두 Lambda와 연동이 되지만 나중에는 GET을 통해 S3에 있는 정적 HTML을 불러와야 하므로 REST API로 생성한다.

방금 만든 IoT_Lamp_API 좌측 탭에서 리소스에서 새로운 리소스를 생성해야한다. 리소스 이름은 shadow-state로 설정한 뒤 API Gateway CORS 활성화 여부에 체크를 해준다.

새로 생성한 리소스인 shdow-state 아래에 새로운 GET 과 POST 메소드를 만들어 Lambda와 매핑시키도록 한다.

이제 작업버튼을 클릭해 배포한다. 만약 배포스테이지가 없다면 새 스테이지에서 Dev 배포 스테이지를 만들어 배포한다.

7. Create S3 Bucket and upload static HTML

AWS S3는 Simple Stroage Service 의 약자로 AWS 에서 제공하는 Cloud Stroage 이다. AWS S3에 데이터를 저장하기 위해서는 bucket을 생성해야하는데 AWS 에서 bucket이란 다음을 지칭한다.

Amazon S3에 데이터를 저장하려면 버킷 및 객체라는 리소스를 사용합니다. 버킷은 객체에 대한 컨테이너입니다. 객체는 파일과 해당 파일을 설명하는 모든 메타데이터입니다.

Amazon S3에 객체를 저장하려면 버킷을 생성한 다음 버킷에 객체를 업로드합니다. 객체가 버킷에 있으면 객체를 열고 다운로드하고 이동할 수 있습니다. 객체나 버킷이 더 이상 필요하지 않은 경우 리소스를 정리할 수 있습니다.

출처: AmazonS3 UserGuide - Working with buckets

AWS 관리 콘솔에서 S3에 접속 후 버킷 탭으로 들어가 새로운 bucket을 만들어 보자. bucket에 이름을 정할때는 몇 가지 규칙이 존재하는데 소문자만 가능하고 특수문자는 dot(.) 과 hyphens(-) 만 지원하고 또 URL 형식은 권장하지 않는다. 자세한 내용이 궁금하다면 🔗 AWS S3 Bucket naming rules 에 접속해 확인해 보자.

이름을 정했다면 그 외 모든 옵션은 디폴트로 선택한 뒤 생성하면 된다. bucket을 생성했으니 아래 코드로 HTML파일을 하나 만든다.

<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>IoT Lamp</title>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/bulma/0.7.5/css/bulma.min.css">
    <script defer src="https://use.fontawesome.com/releases/v5.3.1/js/all.js"></script>
    <script type = "text/javascript"
       src = "https://ajax.googleapis.com/ajax/libs/jquery/2.1.3/jquery.min.js">
    </script>
 
    <script type="text/javascript">
    $(window).load(function() {
    });
 
      $(document).ready(function() {
         $("#onoff").click(function(event){
 
            currentvalue = document.getElementById('onoff').innerHTML;
            if(currentvalue == "It's Off"){
                    // trying to add the value from text box 
                    thingName = document.getElementById("txtField").value;
                    console.log(thingName);
                    var mydata={"action":"on", "thingname":thingName};
                    console.log(mydata);
                    document.getElementById("onoff").innerHTML="It's On";
                    document.getElementById("onoff").setAttribute("class","button is-rounded is-large is-fullwidth is-loading");
                      $.ajax( {
                        type: 'POST',
                         url:'',
                         contentType: 'application/json',
                         crossDomain: true,
                         processData: false,
                         dataType: "json",
                         data: JSON.stringify(mydata),
                         success:function(data) {
                           console.log(" on success");
                            document.getElementById("onoff").setAttribute("class","button is-success is-rounded is-large is-fullwidth");
                         },
                         error:function(data) {
                           console.log(" on fail;");
                            document.getElementById("onoff").setAttribute("class","button is-success is-rounded is-large is-fullwidth");
                         }
                      });
            }
            else {
                document.getElementById("onoff").innerHTML="It's Off";
                // trying to add the value from text box 
                thingName = document.getElementById("txtField").value;
                console.log(thingName);
                var mydata={"action":"off", "thingname":thingName};
                console.log(mydata);
                document.getElementById("onoff").innerHTML="It's Off";
                document.getElementById("onoff").setAttribute("class","button is-rounded is-large is-fullwidth is-loading");
                  $.ajax( {
                    type: 'POST',
                     url:'',
                     contentType: 'application/json',
                     crossDomain: true,
                     processData: false,
                     dataType: "json",
                     data: JSON.stringify(mydata),
                     success:function(data) {
                       console.log(" off success");
                        document.getElementById("onoff").setAttribute("class","button is-danger is-rounded is-large is-fullwidth");
                     },
                     error:function(data) {
                       console.log(" off fail");
                        document.getElementById("onoff").setAttribute("class","button is-danger is-rounded is-large is-fullwidth");
                     }
                  });
            }
         });
 
         $("#fndbtn").click(function(event){
            console.log("testing the button");
            //check the status of Shadow
            // thingName = "ESP32"
            thingName = document.getElementById("txtField").value;
            console.log(`thingname=${thingName}`);
            $.ajax( {
              type: 'GET',
               url:'',
               contentType: 'application/json',
               crossDomain: true,
               processData: false,
               dataType: "json",
               data: `thingname=${thingName}`,
               success:function(data) {
                console.log("success");
                console.log(data.status);
                document.getElementById("onoff").innerHTML=data.status;
                if (data.status == "It's On" )
                {
                  document.getElementById("onoff").setAttribute("class","button is-success is-rounded is-large is-fullwidth");
                }
                else{
            
                  document.getElementById("onoff").setAttribute("class","button is-danger is-rounded is-large is-fullwidth");
                }
               },
               error:function(data) {
                 console.log("error");
               }
            });
        });
      });
 
</script>
  </head>
  <body>
    <div class="columns is-mobile">
    <div class="column is-2">
    <!-- First Column-->
    </div>
    <div class="column is-8">
      <br><br><br><br><br>
      <h1 class="title is-1" style="text-align: center;">IoT Lamp</h1>
      <br><br>
      <center>
        <p>Enter Thing Name: </p>
        &nbsp
      </center>
      <center>
        <input name="txtField" type="text" maxlength="512" id="txtField" class="searchField" style="padding: 8px;" />
        &nbsp
        <!-- <input type = "submit" id = "fndbtn" value = "Submit"/> -->
        <a class="button" id = "fndbtn">Check</a>
      </center>
      <br><br>
      <a class="button is-info is-rounded is-large is-fullwidth" id="onoff" value="on">Pending Check</a>
 
    </div>
    <div class="column is-2">
    <!-- Third Column-->
    </div>
  </div>
  </body>
</html>

위 HTML 코드에 31, 58, 84번 라인의 url 부분이 공란인 것을 확인할 수 있는데 여기에 아까 우리가 만들었던 POST 와 GET의 url을 넣어주면 된다. url 확인은 API Gateway 콘솔에서 IoT_Lamp_API 탭으로 들어간 뒤, 스테이지 영역을 클릭하면 확인할 수 있다.

8. AWS API Gateway S3 Integration

이제 AWS API Gateway와 S3를 연동해보자. 이번 섹션이 끝나면 브라우저 창에 AWS Gateway에서 만든 AWS IoT Lamp API의 API를 통해 실제 Lamp를 제어하는 Web으로 접속할 수 있다.

우선 API Gateway가 S3에 접근할 수 있는 Role을 만들어 보자 IAM 콘솔에 접속한 뒤 좌측 패널 액세스 관리 ➜ 역할 에 접속해 역할 만들기 를 클릭해 새로운 역할을 만들자.

신뢰할 수 있는 유형의 개체 선택 란에서 AWS 서비스 와 또는 서비스를 선택하여 해당 서비스의 사용 사례 확인 란에서 API Gateway를 선택하자 모든 스테이지를 디폴트로 설정한 뒤 역할 이름을 정한다. 역할 이름은 APIGatewayAccessS3로 설정한다.

역할을 만들었으니 이 역할과 연결될 정책을 생성한다. 액세스 관리 ➜ 정책 에 접속해 정책 생성을 클릭한뒤 JSON 탭에 들어가 아래 JSON 문서를 붙여 넣기한다.

{
   "Version":"2012-10-17",
   "Statement":[
      {
         "Effect":"Allow",
         "Action":[
            "s3:GetObject"
         ],
         "Resource":"arn:aws:s3:::<bucket_name>/<object_name>"
      }
   ]
}

<bucket_name>/<object_name> 은 각자의 bucket과 bucket안에 HTML 파일을 넣어주면된다. 이번 실습을 이름까지 똑같이 따라했다면 iot-lamp-bucket/IoT_Lamp.html 을 적어주면 된다. 정책 이름은 IoTLampBucketAccessPolicy 로 정했다.

다시 역할 탭으로 들어가 APIGatewayAccessS3에 권한탭에서 방금만든 IoTLampBucketAccessPolicy 정책을 연결한다.

이제 API Gateway의 IoT_Lamp_API의 루트 리소스에서 새로운 GET 메소드를 생성하자.

메소드를 생성한 뒤 좌측 탭에서 설정란으로 들어가 이진 미디어 형식 에 이진 미디어 형식 추가 버튼을 누르고 다음과 같이 작성한다.

설정을 마치면 다시 배포를 눌러 API를 배포한뒤 웹 브라우져에서 루트 리소스로 접속을 시도해보자.

9. Test

Enter Thing Name에 우리가 만든 사물 이름인 ESP32를 적고 Pending Check 버튼을 누른 후 on/off 를 함에따라 Lamp 역시 on/off가 되는 것을 확인할 수 있다.

디바이스 섀도우 상태 문서를 확인하면 desired 와 reported에 status 라는 속성이 추가도있음을 확인할 수있다.

이밖에 CloudWatchlog 나 Mqtt Test를 이용해 Lambda를 트리거링이 잘 되는것 역시 확인 가능하다.

🔗 Connecting AWS with ESP32 Create an IoT Lamp