[Hands-On] AWS IoT Core를 활용한 확장 가능한 IoT 아키텍처 설계

댓글 달기 / 전체 / 글쓴이

1. 개요

사물인터넷(IoT) 기술이 발전함에 따라 수많은 디바이스에서 발생하는 데이터를 효율적으로 수집하고 관리하는 능력이 현대 클라우드 아키텍처의 핵심 요소가 되었습니다. 하지만 수백만 대의 디바이스를 안전하게 연결하고, 끊김 없는 메시지 통신을 유지하며, 데이터를 적재적소에 배분하는 인프라를 직접 구축하는 것은 매우 복잡한 일입니다.

이번 포스팅에서는 AWS IoT Core를 활용하여 가상의 디바이스를 클라우드에 연결하고, MQTT 프로토콜을 통해 메시지를 주고받는 전 과정을 다룹니다. 특히 보안을 위한 인증서 설정부터 데이터의 흐름을 제어하는 규칙 엔진 활용법까지 실습을 통해 깊이 있게 살펴보겠습니다.

2. 학습 목표

본 실습을 마친 후에는 다음의 역량을 갖출 수 있습니다.

  • AWS IoT Core의 핵심 구성 요소와 작동 원리를 이해합니다.
  • 디바이스 게이트웨이를 통해 사물(Thing)을 등록하고 보안 인증서를 관리하는 방법을 익힙니다.
  • MQTT 프로토콜을 사용하여 클라우드와 디바이스 간의 Pub/Sub 통신을 구현합니다.
  • 규칙 엔진을 설정하여 수집된 데이터를 다른 AWS 서비스로 라우팅하는 기본 구조를 파악합니다.

3. AWS IoT Core란?

AWS IoT Core는 수십억 개의 디바이스를 연결하고 수조 개의 메시지를 다른 AWS 서비스로 안전하게 라우팅할 수 있게 해주는 관리형 클라우드 서비스입니다. 디바이스가 클라우드에 연결되지 않은 상태에서도 항상 상호 작용할 수 있도록 지원하며, 다음과 같은 핵심 구성 요소로 이루어져 있습니다.

  • 디바이스 게이트웨이 (Device Gateway): 디바이스가 AWS에 연결되는 진입점입니다. 보안을 위해 TLS 인증을 사용하며, 효율적인 통신을 위해 MQTT, HTTP, WebSockets 프로토콜을 지원합니다.
  • 메시지 브로커 (Message Broker): 게시 및 구독 모델을 사용하여 메시지를 전송합니다. 디바이스와 클라우드 애플리케이션 간의 고성능 메시지 처리를 담당합니다.
  • 규칙 엔진 (Rules Engine): 수신된 메시지를 필터링하고 가공하여 AWS Lambda, Amazon S3, Amazon DynamoDB 등 다른 서비스로 데이터를 전달합니다. SQL 유사 구문을 사용하여 유연한 데이터 처리가 가능합니다.
  • 디바이스 섀도우 (Device Shadow): 디바이스의 현재 상태 정보를 저장하는 JSON 문서입니다. 디바이스가 오프라인 상태일지라도 애플리케이션이 마지막 상태 값을 읽거나, 다시 연결되었을 때 변경될 상태를 미리 설정할 수 있게 합니다.

4. 사전 준비

서버 생성 및 sdk 설치

dnf -y install python-pip3
mkdir -p ~/environment/dummy_client/certs/
cd ~/environment/dummy_client/


python3 -m venv venv
source venv/bin/activate

python3 -m pip install awsiotsdk
wget 'https://static.us-east-1.prod.workshops.aws/public/4bd9eca7-3826-46d9-94fa-a2a69774089f/static/code/dummy_client/device_main.py' -O device_main.py

Linux 서버를 생성하고, 위 명령어를 통해 실습에 필요한 것들을 파일을 다운로드 받습니다.

5. IoT Core 셋업

5.1 AWS IoT Core 설정

먼저, AWS IoT Core를 사용하기 위해 필요한 설정과 디바이스에서 통신을 수행하기 위해 필요한 리소스를 생성해 나가겠습니다.

5.1.1 AWS IoT 엔드포인트 확인

AWS IoT 코어 > 연결 > 도메인 구성
iot: Data-ATS의 도메인 이름 값을 메모합니다.
– aisof6e2efk53-ats.iot.ap-northeast-2.amazonaws.com

5.1.2 AWS IoT 로그 설정

그 다음 AWS IoT 설정 화면에서 AWS IoT 로그가 출력되도록 설정을 한다.

  1. 설정 메뉴를 클릭하고 로그 관리 버튼을 누른다.
  2. 역할 생성 버튼 > ‘AWSIoTLogRole’을 입력하고 생성하면 적절한 권한을 가진 역할이 새로 생성된다.
  3. 로그 수준에서 ‘정보 제공(INFO)’로 설정 후 업데이트하면 로그가 출력된다.

5.1.3 IoT 정책 생성

AWS IoT > 보안 > 정책

  1. 정책명에 {이름}-{날짜}-policy를 입력
  2. 빌더를 선택 후
  • 정책 효과: 허용
  • 정책 작업: *
  • 정책 리소스: *
  1. 생성
본 핸즈온에서는 절차를 간략화하기 위해 권한이 넓은 정책을 작성하고 있습니다만, 보안 모범 사례에서는 최소한의 권한을 설정하는 것이 권장되고 있습니다. 최소 권한 정책을 설정할 경우 아래 예시와 같이 됩니다. ap-northeast-2 및 123456789012 부분은 사용하는 지역과 계정번호로 대체해 주세요. 

덧붙여 이 정책에서는 AWS IoT Core로의 접속, data/<사물의 이름> 토픽에 대한 Publish 및 Classic Shadow에 관련된 토픽에 대한 Publish, Subscribe, Receive를 허용하고 있습니다.

정책 JSON

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "iot:Connect",
      "Resource": "arn:aws:iot:ap-northeast-2:123456789012:client/${iot:Connection.Thing.ThingName}"
    },
    {
      "Effect": "Allow",
      "Action": "iot:Publish",
      "Resource": [
        "arn:aws:iot:ap-northeast-2:123456789012:topic/data/${iot:Connection.Thing.ThingName}",
        "arn:aws:iot:ap-northeast-2:123456789012:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update",
        "arn:aws:iot:ap-northeast-2:123456789012:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/get"
      ]
    },
    {
      "Effect": "Allow",
      "Action": "iot:Receive",
      "Resource": [
        "arn:aws:iot:ap-northeast-2:123456789012:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update/delta",
        "arn:aws:iot:ap-northeast-2:123456789012:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update/accepted",
        "arn:aws:iot:ap-northeast-2:123456789012:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update/rejected",
        "arn:aws:iot:ap-northeast-2:123456789012:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/get/accepted",
        "arn:aws:iot:ap-northeast-2:123456789012:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/get/rejected"
      ]
    },
    {
      "Effect": "Allow",
      "Action": [
        "iot:Subscribe"
      ],
      "Resource": [
        "arn:aws:iot:ap-northeast-2:123456789012:topicfilter/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update/delta",
        "arn:aws:iot:ap-northeast-2:123456789012:topicfilter/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update/accepted",
        "arn:aws:iot:ap-northeast-2:123456789012:topicfilter/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update/rejected",
        "arn:aws:iot:ap-northeast-2:123456789012:topicfilter/$aws/things/${iot:Connection.Thing.ThingName}/shadow/get/accepted",
        "arn:aws:iot:ap-northeast-2:123456789012:topicfilter/$aws/things/${iot:Connection.Thing.ThingName}/shadow/get/rejected"
      ]
    }
  ]
}

5.1.4 사물 생성

관리 > 사물 > 사물 생성
단일 사물 생성 클릭합니다.

사물 이름에 {이름}-yyyymmdd 등을 입력합니다.
디바이스 섀도우는 이름 없는 섀도우(클래식) 클릭

새 인증서 사용(권장) 클릭

이전에 만든 정책 클릭 후 사물 생성

각각의 오른쪽 다운로드를 클릭하여 자신의 PC로 이 3가지를 다운로드합니다.

공용 키는 본 핸즈온에서는 사용하지 않기 때문에 다운로드할 필요가 없습니다. 또한 화면 아래의 루트 CA 증명서는 3.2.2에서 디바이스에 다운로드하기 때문에 여기에서는 다운로드 할 필요가 없습니다.

5.2 디바이스 설정

디바이스를 기동할 수 있게 설정합니다.

5.2.1 인증서 파일 업로드

업로드할 파일은 아래 두 가지입니다.

  • 인증서: *-certificate.pem.crt
  • 개인키: *-private.pem.key
cd ~/environment/dummy_client/certs
vi aec15a546bc41e2b148c383aea31c4d83ab5a8d6bac5ed1316858a4cfa86bd81-private.pem.key
vi aec15a546bc41e2b148c383aea31c4d83ab5a8d6bac5ed1316858a4cfa86bd81-certificate.pem.crt

5.2.2 루트 CA 인증서 다운로드

터미널에서 다음과 같은 명령을 실행합니다.

cd ~/environment/dummy_client/certs
wget <https://www.amazontrust.com/repository/AmazonRootCA1.pem>

파일 배치는 아래와 같습니다.

$HOME
└── environment
    └── dummy_client
        ├── certs
        │   ├── aec15a546bc41e2b148c383aea31c4d83ab5a8d6bac5ed1316858a4cfa86bd81-certificate.pem.crt
        │   ├── aec15a546bc41e2b148c383aea31c4d83ab5a8d6bac5ed1316858a4cfa86bd81-private.pem.key
        │   └── AmazonRootCA1.pem
        └── device_main.py

5.3 디바이스 기동

지금까지 준비한 프로그램이나 파일을 이용해 가상 디바이스를 기동해, AWS IoT Core와 통신합니다.

5.3.1 Device SDK를 사용한 디바이스의 기동

터미널에서 다음 명령을 실행하여 장치를 시작합니다.

cd ~/environment/dummy_client/

# python3 device_main.py --device_name {생성한 사물의 이름} --endpoint {AWS IoT의 endpoint_url}
python3 device_main.py --device_name <name>-<date> --endpoint aisof6e2efk53-ats.iot.ap-northeast-2.amazonaws.com
상기 명령어를 실행하면 더미 디바이스는 AWS IoT Core로 MQTT로 접속해, 5초 간격(디폴트 설정)으로 메시지를 송신합니다

명령어 실행하면 위와 같은 결과가 반환된다. 맨 아래의 topic을 메모합니다.

5.3.2 소통테스트

AWS IoT 코어 > MQTT 테스트 클라이언트
주제 구독의 필터에 아까 메모해둔 topic을 입력하고 구독 클릭
그러면 화면 하단의 구독에서 전송된 데이터를 확인할 수 있습니다.

아래의 JSON 문이 수신 받은 메세지고 이로써 가상 디바이스에서 클라우드(AWS IoT Core)로 메시지가 전송되고 있음을 확인할 수 있습니다.

5.4 디바이스 섀도 확인

디바이스 제어나 설정을 원할 경우 디바이스 섀도 기능을 이용할 수 있습니다. 여기서는 디바이스 섀도를 활용해 디바이스의 메시지 전송 빈도를 원격으로 제어해보겠습니다.

5.4.1 디바이스 섀도우 업데이트

AWS IoT > 관리 > 사물
생성한 사물의 디바이스 섀도우 탭을 클릭하고 이미 생성되어 있는 “클래식 섀도우”를 클릭합니다.

디바이스 섀도우 문서의 편집을 클릭하여 내용을 수정합니다.
Classic Shadow 화면에서 Device Shadow 문서 의 편집 버튼을 누릅니다.

표시된 편집 화면에서 섀도우 내용을 아래 JSON으로 변경합니다.

{
    "state": {
        "reported": {
            "wait_time": 5
        },
        "desired": {
            "wait_time": 1
        }
    }
}

desired 안에 “welcome”: “aws-iot”이라는 속성이 들어간 경우 “welcome”: null로 다시 쓰면 삭제할 수 있습니다.
이 desired > wait_time 값을 변경하면 디바이스가 데이터를 송신하는 빈도가 바뀝니다.

섀도우 문서에서 desired는 장치에 지시된 상태, reported는 장치에서 보고된 상태입니다. desired와 reported 상태에 차이가 있을 경우 delta라는 필드에 차이가 표시됩니다

5.4.2 디바이스에서 섀도우 확인

Received shadow delta event.  # Shadow 업데이트를 받아 상태를 변경하고 있음
  Delta reports that desired value is '1'. Changing local value from '5' to '1'
Updating reported shadow to...
Update request published.  # Shadow에게 자신의 상태 변경을 보고
on_update_shadow_accepted

디바이스 섀도우 기능에 의해 delta(차이 정보)가 디바이스에 통지되어 디바이스 내에서 송신 간격의 변경이 이루어집니다. 터미널을 보면, 추가적으로 reported(자신의 상태)를 AWS IoT Core에 통지하고 있는 것을 확인할 수 있습니다.

다시 사물화면에서 wait_time을 변경하여 저장하면 반영되는 것을 확인할 수 있습니다. 예를 들면 desired -> wait_time 값을 2로 변경하면 터미널에서도 변경을 확인할 수 있습니다.

5.4.3 소통테스트

아까와 마찬가지로 토픽을 구독하면 데이터가 전송되는 간격이 변경된 것을 확인할 수 있습니다.

예를 들면, 조금 전 wait_time을 2로 변경했기 때문에, 메시지가 2초 간격으로 송신되고 있는 것을 확인할 수 있습니다.

6. 애플리케이션용 DB 생성

6.1 Kinesis Data Stream 생성

6.1.1 스트림 생성

데이터 스트림 이름: {이름}-{날짜}

용량 모드: 온디맨드

나머지는 기본값으로 두고 생성합니다.

6.1.2 생성 확인

스트림 목록 화면으로 전환되며, 생성한 스트림의 상태가 생성 중 -> 활성으로 변경되면 완료됩니다.

6.2 DynamoDB 생성

6.2.1 테이블 생성

테이블 이름: {이름}-{날짜}

파티션 키: deviceid | 문자열

정렬 키: timestamp | 문자열

활성 상태가 된 것을 확인합니다.

6.3 IAM 설정

6.3.1 Lambda에서 사용할 IAM 역할 생성

IAM 역할 생성을 클릭하고 신뢰할 수 있는 엔터티로 Lambda를 지정합니다.

  • 역할 이름: {이름}-{날짜}-lambda
  • 신뢰할 수 있는 엔터티:
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "sts:AssumeRole"
            ],
            "Principal": {
                "Service": [
                    "lambda.amazonaws.com"
                ]
            }
        }
    ]
}
  • 권한
    • AmazonDynamoDBFullAccess
    • AmazonKinesisReadOnlyAccess
    • AWSLambdaBasicExecutionRole

설정 후 Lambda용 IAM 역할을 생성합니다.

6.3.2 AWS IoT용 IAM Role 생성

IAM 역할 생성을 클릭하고 신뢰할 수 있는 엔터티로 IoT를 지정합니다.

  • 역할 이름: {이름}-{날짜}-iot
  • 신뢰할 수 있는 엔터티:
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "",
            "Effect": "Allow",
            "Principal": {
                "Service": [
                    "iot.amazonaws.com"
                ]
            },
            "Action": [
                "sts:AssumeRole"
            ]
        }
    ]
}
  • 권한
    • AWSIoTLogging
    • AWSIoTRuleActions
    • AWSIoTThingsRegistration

설정 후 Iot용 IAM 역할을 생성합니다.

6.4 Lambda 설정

6.4.1 신규 함수 생성

  • 함수 이름: {이름}-{날짜}
  • 런타임: Python 3.12
  • 아키텍처: x86_64
  • 실행 역할: 기존 역할 사용

설정 후 Lambda 함수를 생성합니다.

6.4.2 트리거 추가

6.4.3 Kinesis 트리거 설정

  • 트리거 구성: Kinesis
  • Kinesis 스트림: kinesis/<name>-<date>
  • 나머지 옵션은 기본값

입력 후 추가를 클릭합니다.

6.4.4 구현

트리거 하부에서 코드 탭 선택

lambda_function.py

from __future__ import print_function
import base64
import boto3
from boto3.dynamodb.conditions import Key, Attr
import json
import os
import traceback

#-----Dynamo Info change here------
TABLE_NAME = os.environ.get('TABLE_NAME', "default")
DDB_PRIMARY_KEY = "deviceid"
DDB_SORT_KEY = "timestamp"
DDB_ATTR = "temp"
#-----Dynamo Info change here------

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

'''
This Kinesis data(Json Image) is below
{
    "DEVICE_NAME": $device_name,
    "TIMESTAMP": $TimeStamp(yyyy-mm-ddThh:MM:SS),
    "HUMIDITY" : int,
    "TEMPERATURE" : int
}
'''
def checkItem(str_data):
    try:
        #String to Json object
        json_data = json.loads(str_data)
        # adjust your data format
        resDict = {
            DDB_PRIMARY_KEY:json_data['DEVICE_NAME'],
            DDB_SORT_KEY:json_data['TIMESTAMP'],
            "HUMIDITY": json_data['HUMIDITY'],
            "TEMPERATURE": json_data['TEMPERATURE']

        }
        print("resDict:{}".format(resDict))
        return resDict

    except Exception as e:
        print(traceback.format_exc())
        return None

def writeItemInfo(datas):
    ItemInfoDictList = []
    try:
        for data in datas:
            itemDict = checkItem(data)
            if None != itemDict:
                ItemInfoDictList.append(itemDict)
            # if data does not have key info, just pass
            else:
                print("Error data found:{}".format(data))
                pass

    except Exception as e:
        print(traceback.format_exc())
        print("Error on writeItemInfo")

    return ItemInfoDictList

def DynamoBulkPut(datas):
    try:
        putItemDictList = writeItemInfo(datas)
        with table.batch_writer() as batch:
            for putItemDict in putItemDictList:
                batch.put_item(Item = putItemDict)
        return

    except Exception as e:
        print("Error on DynamoBulkPut()")
        raise e

def decodeKinesisData(dataList):
    decodedList = []
    try:
        for data in dataList:
            payload =  base64.b64decode(data['kinesis']['data'])
            print("payload={}".format(payload))
            decodedList.append(payload)

        return decodedList

    except Exception as e:
        print("Error on decodeKinesisData()")
        raise e

#------------------------------------------------------------------------
# call by Lambda here.
#------------------------------------------------------------------------
def lambda_handler(event, context):
    print("lambda_handler start")

    try:
        print("---------------json inside----------------")
        print(json.dumps(event))
        encodeKinesisList = event['Records']
        print(encodeKinesisList)
        decodedKinesisList = decodeKinesisData(encodeKinesisList)
        # Dynamo Put
        if 0 < len(decodedKinesisList):
            DynamoBulkPut(decodedKinesisList)
        else:
            print("there is no valid data in Kinesis stream, all data passed")

        return

    except Exception as e:
        print(traceback.format_exc())
        # This is sample source. When error occur this return success and ignore the error.
        raise e

기존 코드를 삭제하고 위의 코드를 복사하여 lambda_function.py에 붙여 넣습니다.

그 후 Deploy를 클릭하여 적용합니다.

Deploy 버튼을 누르지 않으면 변경 사항이나 설정이 저장되지 않으므로, 변경 시에는 반드시 눌러 주세요.

6.4.5 환경 변수의 지정

구성 탭의 환경 변수를 클릭하여 변수를 입력합니다.

환경 변수

  • 키: TABLE_NAME
  • 값: <name>-<date> (DynamoDB 테이블 이름)

입력하고 환경 변수를 설정합니다.

6.5 AWS IoT Core 설정

6.5.1 신규 규칙 생성

AWS IoT > 메시지 라우팅 > 규칙

  • 규칙 이름: <name>_<date>

SQL 문에 다음과 같이 작성합니다.

select * from '자신의 토픽명'

6.5.2 규칙 작업 연결

규칙 작업을 설정합니다.
작업: Kinesis 데이터 스트림
스트림 이름: <name>-<date>
파티션 키: ${newuuid()}
IAM 역할: <name>-<date>-iot

마지막으로 설정한 것이 맞는 지 확인 후 규칙을 생성합니다.

6.5.3 소통테스트

AWS IoT Core에서 MQTT 테스트 클라이언트에 구독을 눌러 테스트를 합니다.

6.5.4 Kinesis 동작 확인

데이터 반영까지 몇 분 걸립니다.

이전에 만든 Kinesis 스트림을 클릭하여 모니터링을 확인합니다.

스트림 메트릭에서 GetRecords - 합계(수) や PutRecord - 합계(MB/초) 의 값이 0이 아님을 확인할 수 있습니다.

  • AWS IoT에서 Put / Lambda에서 Get가 매트릭스로 나타나는 것을 확인할 수 있습니다

6.5.5 DynamoDB 동작 확인

이전에 생성한 DynamoDB 테이블에 ‘표 항목 탐색’을 클릭합니다.

디바이스에서 데이터가 투입된 것을 확인할 수 있습니다.

6.5.6 Lambda 동작 확인

생성한 Lambda 함수의 모니터링을 확인한다.

  • 호출의 개수가 0이 아니고, 에러의 개수가 0인지 확인

6.6 API용 Lambda의 설정

6.6.1 Lambda 함수 생성

  • 함수 이름: <name>-<date>-api
  • 런타임: Python 3.14
  • 아키텍처: x86_64
  • 실행 역할: 기존 역할 사용 – <name>-<date>-lambda

위와 같이 설정한 뒤 새로운 Lambda 함수를 생성합니다.

6.6.2 코드 반영

lambda_function.py 

from __future__ import print_function
import boto3
from boto3.dynamodb.conditions import Key
import datetime
import json
import traceback
import os

#-----Dynamo Info change here------
TABLE_NAME = os.environ.get('TABLE_NAME', "default")
DDB_PRIMARY_KEY = "deviceid"
DDB_SORT_KEY = "timestamp"
#-----Dynamo Info change here------

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

#------------------------------------------------------------------------
def dynamoQuery(deviceid, requestTime):
    print("dynamoQuery start")
    valList = []
    res = table.query(
        KeyConditionExpression=
            Key(DDB_PRIMARY_KEY).eq(deviceid) &
            Key(DDB_SORT_KEY).lt(requestTime),
            ScanIndexForward = False,
            Limit = 30
        )

    for row in res['Items']:
        val = row['TEMPERATURE']
        itemDict = {
            "timestamp":row['timestamp'],
            "value":int(val)
        }
        valList.append(itemDict)

    return valList

#------------------------------------------------------------------------
# call by Lambda here.
#  Event structure : API-Gateway Lambda proxy post
#------------------------------------------------------------------------
def lambda_handler(event, context):
    #Lambda Proxy response back template
    HttpRes = {
        "statusCode": 200,
        "headers": {"Access-Control-Allow-Origin" : "*"},
        "body": "",
        "isBase64Encoded": False
    }

    try:
        print("lambda_handler start")
        print(json.dumps(event))

        # get Parameters
        pathParameters = event.get('pathParameters')
        deviceid = pathParameters["deviceid"]
        requestTime = datetime.datetime.now().strftime('%Y-%m-%dT%H:%M:%S')

        resItemDict = { deviceid : ""}
        resItemDict[deviceid] = dynamoQuery(deviceid, requestTime)
        HttpRes['body'] = json.dumps(resItemDict)

    except Exception as e:
        print(traceback.format_exc())
        HttpRes["statusCode"] = 500
        HttpRes["body"] = "Lambda error. check lambda log"

    print("response:{}".format(json.dumps(HttpRes)))
    return HttpRes

새로 만든 함수에 위의 코드를 붙여 넣고 Deploy를 누릅니다.

6.6.3 환경 변수 추가

구성 탭의 환경 변수를 클릭하여 변수를 추가합니다.

  • 키: TABLE_NAME
  • 값: {DynamoDB_TALBE_NAME}
    • <name>-<date>

6.7 API Gateway 설정

6.7.1 API Gateway 생성

REST API를 선택하여 구성합니다.

  • 새 API
  • API 이름: {이름}-{날짜|
    • <name>-<date>
  • API 엔드포인트 유형: 지역

6.7.2 리소스 생성

리소스 생성을 클릭하고 리소스 이름을 datas로 입력한 뒤 생성합니다.

/datas 를 클릭하고 다시 리소스 생성을 클릭합니다.

리소스 이름을 {deviceid}로 입력하고 생성합니다.

6.7.3 메서드 생성

  • 메서드 유형: GET
  • 통합 유형: Lambda
  • Lambda 프록시 통합: 활성화
  • 응답 전송 모드: 버퍼됨
  • Lambda 함수: 위에서 만든 함수 ({이름}-{날짜}-api)

GET 실행 시에 Lambda를 호출하는 설정을 완료했습니다.

6.7.4 CORS 설정

/data/{deviceid} 경로를 누르고 CORS 활성화를 클릭합니다.

GET을 선택하고 저장합니다.

6.7.5 API 배포 실행

API 배포를 클릭합니다. 이를 통해 생성된 API가 공개되고, Global에서 접근 가능한 URI가 생성됩니다.

배포를 완료하면 URL이 생성됩니다.

6.7.6 동작 확인

DrawGraph.zip

여기에서 소스 코드를 다운로드합니다.

DrawGraph 폴더 내 js/crateGraph.js를 열고 아래 부분을 편집

위의 수정 후에 자신의 PC에서 DrawGraph 폴더내 drawGraphIndex.html를 브라우저로 기동

아래와 같은 그래프가 표시되면 OK

위 그래프에서는 DynamoDB에 저장된 디바이스의 TEMPERATURE 값을 보여주고 있습니다.

7. 마무리

이번 실습을 통해 AWS IoT Core가 단순히 ‘연결’만 제공하는 서비스가 아니라, 보안부터 데이터 흐름 제어까지 IoT 생태계의 중추 역할을 한다는 것을 확인할 수 있었습니다.

특히 별도의 서버 관리 없이수많은 기기의 메시지를 안정적으로 처리할 수 있다는 점은 대규모 IoT 프로젝트에서 큰 강점으로 다가옵니다. 이번에는 기초적인 연결과 라우팅을 다루었지만, 이를 응용한다면 실시간 모니터링 대시보드 구축이나 예측 유지보수를 위한 머신러닝 연동까지 확장할 수 있을 것입니다.

클라우드 기반의 IoT 환경을 고민하고 있다면, AWS IoT Core는 가장 강력하고 유연한 선택지가 될 것입니다.

8. 참고문서

  • https://catalog.us-east-1.prod.workshops.aws/workshops/fda82638-2464-49f9-b6af-0e72b157d1a9/en-US
  • https://catalog.us-east-1.prod.workshops.aws/workshops/850fcd5c-fd1f-48d7-932c-ad9babede979/en-US
  • https://github.com/awslabs/amazon-bedrock-agentcore-samples
  • https://github.com/build-on-aws/agentic-workshop

댓글 달기

이메일 주소는 공개되지 않습니다. 필수 항목은 *(으)로 표시합니다