

기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.

# AWS IoT Device Client를 사용하여 데모 빌드
<a name="iot-tutorials-dc-intro"></a>

이 학습 경로의 자습서에서는 AWS IoT Device Client를 사용하여 데모 소프트웨어를 개발하는 단계를 안내합니다. AWS IoT Device Client는 IoT 디바이스에서 실행되는 소프트웨어를 제공하여 내장된 IoT 솔루션의 측면을 테스트하고 보여줍니다 AWS IoT.

이 자습서의 목표는 디바이스 소프트웨어를 개발하기 전에가 솔루션을 AWS IoT 지원한다고 확신할 수 있도록 탐색 및 실험을 용이하게 하는 것입니다.

**이 자습서에서 배울 내용:**
+ 에서 IoT 디바이스로 사용할 Raspberry Pi를 준비하는 방법 AWS IoT
+ 디바이스에서 AWS IoT Device Client를 사용하여 AWS IoT 기능을 시연하는 방법

이 학습 경로에서는 자체 Raspberry Pi에 AWS IoT Device Client를 설치하고 클라우드에서 AWS IoT 리소스를 생성하여 IoT 솔루션 아이디어를 보여줍니다. 이 학습 경로의 튜토리얼은 Raspberry Pi를 사용하여 기능을 보여주면서 다른 디바이스에 이들을 적용하는 데 도움이 되는 목표와 절차를 설명합니다.

## AWS IoT Device Client로 데모를 빌드하기 위한 사전 조건
<a name="iot-dc-tutorial-overview"></a>

이 섹션에서는 이 학습 경로에서 튜토리얼을 시작하기 전에 갖추어야 할 사항에 대해 설명합니다.

**이 학습 경로의 튜토리얼을 완료하려면 다음이 필요합니다.**
+ 

**의 경우 AWS 계정**  
기존가 있는 AWS 계정경우를 사용할 수 있지만 이러한 자습서에서 AWS IoT 사용하는 기능을 사용하려면 추가 역할 또는 권한을 추가해야 할 수 있습니다.

  새를 생성해야 하는 경우 섹션을 AWS 계정참조하세요[설정 AWS 계정](setting-up.md).
+ 

**Raspberry Pi 또는 호환되는 IoT 디바이스**  
튜토리얼에서는 다양한 폼 팩터로 제공되는 [Raspberry Pi](https://www.raspberrypi.org/)를 사용합니다. Raspberry Pi는 일반적으로 많이 사용하며 비교적 저렴한 데모 디바이스입니다. 튜토리얼은 [Raspberry Pi 3 모델 B\$1](https://www.raspberrypi.com/products/raspberry-pi-3-model-b-plus/), [Raspberry Pi 4 모델 B](https://www.raspberrypi.com/products/raspberry-pi-4-model-b/) 및 Ubuntu Server 20.04 LTS(HVM)를 실행하는 Amazon EC2 인스턴스에서 테스트되었습니다. 를 사용하고 명령을 AWS CLI 실행하려면 최신 버전의 Raspberry Pi OS([Raspberry Pi OS(64비트)](https://www.raspberrypi.com/software/operating-systems/) 또는 OS Lite)를 사용하는 것이 좋습니다. 이전 버전의 OS는 작동하지만 테스트되지 않았습니다.
**참고**  
튜토리얼은 각 단계의 목표를 설명하여 당사에서 시도하지 않은 IoT 하드웨어에 적응하는 데 도움이 됩니다. 그러나 다른 디바이스에 적용하는 방법을 구체적으로 설명하지는 않습니다.
+ 

**IoT 디바이스의 운영 체제에 대한 이해**  
이 튜토리얼의 단계에서는 Raspberry Pi에서 지원하는 명령줄 인터페이스에서 기본 Linux 명령 및 작업을 사용하는 데 익숙하다고 가정합니다. 이러한 작업에 익숙하지 않은 경우 튜토리얼을 완료하는 데 더 많은 시간을 할애해야 할 수 있습니다. 

  이 튜토리얼을 완료하려면 다음 방법에 대한 이해가 필요합니다.
  + 부품 조립 및 연결, 필요한 전원에 디바이스 연결, 메모리 카드 설치 및 제거와 같은 기본 디바이스 작업을 안전하게 수행합니다.
  + 시스템 소프트웨어 및 파일을 디바이스에 업로드하고 다운로드합니다. 디바이스에서 microSD 카드와 같은 이동식 저장 디바이스를 사용하지 않는 경우 디바이스에 연결하고 시스템 소프트웨어와 파일을 디바이스에 업로드 및 다운로드하는 방법을 알아야 합니다.
  + 디바이스를 사용하려는 네트워크에 연결합니다.
  + SSH 터미널 또는 유사한 프로그램을 사용하여 다른 컴퓨터에서 디바이스에 연결합니다.
  + 명령줄 인터페이스를 사용하여 디바이스에 있는 파일 및 디렉터리의 생성, 복사, 이동, 이름 변경 및 권한 설정을 수행합니다.
  + 디바이스에 새 프로그램을 설치합니다.
  + FTP 또는 SCP와 같은 도구를 사용하여 디바이스와 파일을 주고받습니다.
+ 

**IoT 솔루션을 위한 개발 및 테스트 환경**  
튜토리얼에서는 필요한 소프트웨어와 하드웨어를 설명합니다. 그러나 튜토리얼에서는 명시적으로 설명되지 않은 작업을 수행할 수 있다고 가정합니다. 이러한 하드웨어 및 작업의 예는 다음과 같습니다.
  + 

**파일을 다운로드하고 저장할 로컬 호스트 컴퓨터**  
Raspberry Pi의 경우 일반적으로 microSD 메모리 카드를 읽고 쓸 수 있는 개인용 컴퓨터 또는 랩톱입니다. 로컬 호스트 컴퓨터는
    + 인터넷에 연결되어 있어야 합니다.
    + [AWS CLI](https://aws.amazon.com//cli/)를 설치하고 구성합니다.
    +  AWS 콘솔을 지원하는 웹 브라우저가 있어야 합니다.
  + 

**로컬 호스트 컴퓨터를 디바이스에 연결하여 통신하고, 명령을 입력하고, 파일을 전송하는 방법**  
Raspberry Pi에서 이는 종종 로컬 호스트 컴퓨터의 SSH 및 SCP를 사용하여 수행됩니다.
  + 

**IoT 디바이스에 연결할 모니터 및 키보드**  
이들은 도움이 될 수 있지만 튜토리얼을 완료하는 데 필수 사항은 아닙니다.
  + 

**로컬 호스트 컴퓨터와 IoT 디바이스가 인터넷에 연결하는 방법**  
인터넷에 연결된 라우터 또는 게이트웨이에 대한 유선 또는 무선 네트워크 연결일 수 있습니다. 로컬 호스트도 Raspberry Pi에 연결할 수 있어야 합니다. 이를 위해서는 동일한 LAN에 있어야 합니다. 튜토리얼에서는 특정 디바이스 또는 디바이스 구성에 대해 이를 설정하는 방법을 보여줄 수 없지만 이 연결을 테스트하는 방법은 보여줍니다.
  + 

**LAN 라우터에 액세스하여 연결된 디바이스 보기**  
이 학습 경로의 튜토리얼을 완료하려면 IoT 디바이스의 IP 주소를 찾을 수 있어야 합니다.

    LAN에서는 디바이스가 연결된 네트워크 라우터의 관리자 인터페이스에 액세스하여 이를 수행할 수 있습니다. 라우터에서 디바이스에 고정 IP 주소를 할당할 수 있으면 디바이스가 다시 시작될 때마다 재연결을 간소화할 수 있습니다.

    디바이스에 키보드와 모니터가 연결되어 있는 경우 **ifconfig**는 디바이스의 IP 주소를 표시할 수 있습니다.

    이러한 옵션이 없는 경우 재시작할 때마다 디바이스의 IP 주소를 식별하는 방법을 찾아야 합니다.

모든 자료를 준비한 후 [자습서: Device Client용 AWS IoT 디바이스 준비](iot-dc-prepare-device.md) 섹션으로 진행합니다.

**Topics**
+ [AWS IoT Device Client로 데모를 빌드하기 위한 사전 조건](#iot-dc-tutorial-overview)
+ [자습서: Device Client용 AWS IoT 디바이스 준비](iot-dc-prepare-device.md)
+ [자습서: AWS IoT Device Client 설치 및 구성](iot-dc-install-dc.md)
+ [자습서: AWS IoT Device Client와의 MQTT 메시지 통신 시연](iot-dc-testconn.md)
+ [자습서: AWS IoT Device Client를 사용하여 원격 작업(작업) 시연](iot-dc-runjobs.md)
+ [자습서: AWS IoT Device Client 자습서를 실행한 후 정리](iot-dc-cleanup.md)

# 자습서: Device Client용 AWS IoT 디바이스 준비
<a name="iot-dc-prepare-device"></a>

이 튜토리얼에서는 이 학습 경로의 후속 튜토리얼을 위한 준비를 위해 Raspberry Pi를 초기화하는 과정을 안내합니다.

이 튜토리얼의 목표는 현재 버전의 디바이스 운영 체제를 설치하고 개발 환경의 컨텍스트에서 디바이스와 통신할 수 있는지 확인하는 것입니다.

**사전 조건**  
이 자습서를 시작하기 전에 [AWS IoT Device Client로 데모를 빌드하기 위한 사전 조건](iot-tutorials-dc-intro.md#iot-dc-tutorial-overview)에 나열된 항목을 사용할 수 있고 사용할 준비가 되었는지 확인하세요.

이 자습서는 완료하는 데 약 90분이 소요됩니다.

**이 자습서에서 배울 내용은 다음과 같습니다.**
+ 디바이스의 운영 체제 설치 및 업데이트입니다.
+ 자습서를 실행하는 데 필요한 추가 소프트웨어를 설치하고 확인합니다.
+ 디바이스의 연결을 테스트하고 필요한 인증서를 설치합니다.

이 자습서를 완료한 후 다음 자습서에서는 Device Client를 사용하는 데모를 위해 AWS IoT 디바이스를 준비합니다.

**Topics**
+ [디바이스의 운영 체제 설치 및 업데이트](iot-dc-prepare-device-sys.md)
+ [디바이스에 필요한 소프트웨어 설치 및 확인](iot-dc-prepare-device-sw.md)
+ [디바이스 테스트 및 Amazon CA 인증서 저장](iot-dc-prepare-device-test.md)

# 디바이스의 운영 체제 설치 및 업데이트
<a name="iot-dc-prepare-device-sys"></a>

이 섹션의 절차에서는 Raspberry Pi가 시스템 드라이브에 사용하는 microSD 카드를 초기화하는 방법을 설명합니다. Raspberry Pi의 microSD 카드에는 운영 체제(OS) 소프트웨어와 애플리케이션 파일 스토리지 공간이 있습니다. Raspberry Pi를 사용하지 않는 경우 디바이스의 지침에 따라 디바이스의 운영 체제 소프트웨어를 설치하고 업데이트합니다.

이 섹션을 완료한 후에는 IoT 디바이스를 시작하고 로컬 호스트 컴퓨터의 터미널 프로그램에서 연결할 수 있어야 합니다.

**필수 장비:**
+ 로컬 개발 및 테스트 환경
+ 인터넷에 연결할 수 있는 Raspberry Pi 또는 IoT 디바이스
+ 최소 8GB 용량의 microSD 메모리 카드 또는 OS 및 필요한 소프트웨어를 위한 충분한 스토리지.
**참고**  
이러한 연습을 위해 microSD 카드를 선택할 때 필요한 만큼 크지만 가능한 한 작은 카드를 선택합니다.  
작은 SD 카드는 백업 및 업데이트가 더 빠릅니다. Raspberry Pi에서는 이 튜토리얼을 위해 8GB 이상의 microSD 카드가 필요하지 않습니다. 특정 애플리케이션에 더 많은 공간이 필요한 경우 이 튜토리얼에서 저장하는 더 작은 이미지 파일로 더 큰 카드의 파일 시스템 크기를 조정하여 선택한 카드의 지원되는 공간을 모두 사용할 수 있습니다.

**옵션 장비:**
+ Raspberry Pi에 연결된 USB 키보드
+ HDMI 모니터 및 Raspberry Pi에 모니터를 연결하는 케이블

**Topics**
+ [microSD 카드에 디바이스의 운영 체제 로드](#iot-dc-prepare-device-sys-step1)
+ [새로운 운영 체제로 IoT 디바이스 시작](#iot-dc-prepare-device-sys-step2)
+ [디바이스에 로컬 호스트 컴퓨터 연결](#iot-dc-prepare-device-sys-step3)

## microSD 카드에 디바이스의 운영 체제 로드
<a name="iot-dc-prepare-device-sys-step1"></a>

이 절차는 로컬 호스트 컴퓨터를 사용하여 디바이스의 운영 체제를 microSD 카드에 로드합니다.

**참고**  
디바이스가 운영 체제에 이동식 저장 매체를 사용하지 않는 경우 해당 디바이스에 대한 절차를 사용하여 운영 체제를 설치하고 [새로운 운영 체제로 IoT 디바이스 시작](#iot-dc-prepare-device-sys-step2) 섹션으로 진행합니다.

**Raspberry Pi에 운영 체제를 설치하려면**

1. 로컬 호스트 컴퓨터에서 사용하려는 Raspberry Pi 운영 체제 이미지를 다운로드하고 압축을 풉니다. 최신 버전은 [https://www.raspberrypi.com/software/operating-systems/](https://www.raspberrypi.com/software/operating-systems/)에서 구할 수 있습니다.

**Raspberry Pi OS 버전 선택**  
이 학습 경로의 이들 튜토리얼을 지원하는 가장 작은 버전이기 때문에 이 튜토리얼에서는 **Raspberry Pi OS Lite** 버전을 사용합니다. 이 버전의 Raspberry Pi OS에는 명령줄 인터페이스만 있고 그래픽 사용자 인터페이스는 없습니다. 그래픽 사용자 인터페이스가 있는 최신 Raspberry Pi OS 버전도 이 튜토리얼에서도 사용할 수 있습니다. 그러나 이 학습 경로에 설명된 절차는 명령줄 인터페이스만 사용하여 Raspberry Pi에서 작업을 수행합니다.

1. microSD 카드를 로컬 호스트 컴퓨터에 삽입합니다.

1. SD 카드 이미징 도구를 사용하여 압축을 푼 OS 이미지 파일을 microSD 카드에 씁니다.

1. microSD 카드에 Raspberry Pi OS 이미지를 쓴 후

   1. 명령줄 창 또는 파일 탐색기 창에서 microSD 카드의 BOOT 파티션을 엽니다.

   1. microSD 카드의 BOOT 파티션 루트 디렉터리에 파일 확장자와 내용이 없는 `ssh`라는 빈 파일을 생성합니다. 이 파일은 Raspberry Pi가 처음 시작할 때 SSH 통신을 사용 설정하도록 지시합니다.

1. microSD 카드를 꺼내고 로컬 호스트 컴퓨터에서 안전하게 제거합니다.

[새로운 운영 체제로 IoT 디바이스 시작](#iot-dc-prepare-device-sys-step2)에 사용할 microSD 카드가 준비되었습니다.

## 새로운 운영 체제로 IoT 디바이스 시작
<a name="iot-dc-prepare-device-sys-step2"></a>

이 절차는 microSD 카드를 설치하고 다운로드한 운영 체제를 사용하여 처음으로 Raspberry Pi를 시작합니다.

**새로운 운영 체제로 IoT 디바이스를 시작하려면**

1. 디바이스의 전원을 분리한 상태에서 이전 단계인 [microSD 카드에 디바이스의 운영 체제 로드](#iot-dc-prepare-device-sys-step1)의 microSD 카드를 Raspberry Pi에 삽입합니다.

1. 네트워크에 디바이스를 연결합니다.

1. 이 튜토리얼은 SSH 터미널을 사용하여 로컬 호스트 컴퓨터에서 Raspberry Pi와 상호 작용합니다.

   기기와 직접 상호 작용하려면 다음을 수행합니다.

   1. 로컬 호스트 컴퓨터의 터미널 창을 Raspberry Pi에 연결하기 전에 HDMI 모니터를 연결하여 Raspberry Pi의 콘솔 메시지를 확인합니다.

   1. Raspberry Pi와 직접 상호 작용하려면 Raspberry Pi에 USB 키보드를 연결합니다.

1. Raspberry Pi에 전원을 연결하고 초기화될 때까지 1분 정도 기다립니다.

   Raspberry Pi에 모니터가 연결되어 있으면 모니터에서 시작 프로세스를 볼 수 있습니다.

1. 

   디바이스의 IP 주소 찾기:
   + Raspberry Pi에 HDMI 모니터를 연결한 경우 모니터에 표시된 메시지에 IP 주소가 나타납니다.
   + Raspberry Pi가 연결된 라우터에 액세스할 수 있는 경우 라우터의 관리 인터페이스에서 주소를 확인할 수 있습니다.

Raspberry Pi의 IP 주소가 있으면 [디바이스에 로컬 호스트 컴퓨터 연결](#iot-dc-prepare-device-sys-step3) 준비가 된 것입니다.

## 디바이스에 로컬 호스트 컴퓨터 연결
<a name="iot-dc-prepare-device-sys-step3"></a>

이 절차에서는 로컬 호스트 컴퓨터의 터미널 프로그램을 사용하여 Raspberry Pi에 연결하고 기본 암호를 변경합니다.

**디바이스에 로컬 호스트 컴퓨터를 연결하려면**

1. 

   로컬 호스트 컴퓨터에서 SSH 터미널 프로그램을 엽니다.
   + Windows: `PuTTY`
   + Linux/macOS: `Terminal`
**참고**  
PuTTY는 Windows에 자동으로 설치되지 않습니다. 컴퓨터에 없으면 다운로드하여 설치해야 할 수 있습니다.

1. 터미널 프로그램을 Raspberry Pi의 IP 주소에 연결하고 기본 자격 증명을 사용하여 로그인합니다.

   ```
   username: pi
   password: raspberry
   ```

1. Raspberry Pi에 로그인한 후 `pi` 사용자의 암호를 변경합니다.

   ```
   passwd
   ```

   프롬프트에 따라 암호를 변경합니다.

   ```
   Changing password for pi.
   Current password: raspberry
   New password: YourNewPassword
   Retype new password: YourNewPassword
   passwd: password updated successfully
   ```

터미널 창에 Raspberry Pi의 명령줄 프롬프트가 표시되고 암호가 변경되면 [디바이스에 필요한 소프트웨어 설치 및 확인](iot-dc-prepare-device-sw.md)으로 진행할 준비가 된 것입니다.

# 디바이스에 필요한 소프트웨어 설치 및 확인
<a name="iot-dc-prepare-device-sw"></a>

이 섹션의 절차는 [이전 섹션에서 계속](iot-dc-prepare-device-sys.md)되어 Raspberry Pi의 운영 체제를 최신 상태로 유지하고 다음 섹션에서 AWS IoT Device Client를 빌드하고 설치하는 데 사용할 소프트웨어를 Raspberry Pi에 설치합니다.

이 섹션을 완료하면 Raspberry Pi에 최신 운영 체제와 이 학습 경로의 튜토리얼에 필요한 소프트웨어가 설치되고 해당 위치에 맞게 구성됩니다.

**필수 장비:**
+ [이전 섹션](iot-dc-prepare-device-sys.md)의 로컬 개발 및 테스트 환경
+ [이전 섹션](iot-dc-prepare-device-sys.md)에서 사용한 Raspberry Pi
+ [이전 섹션](iot-dc-prepare-device-sys.md)의 microSD 메모리 카드

**참고**  
Raspberry Pi 모델 3\$1 및 Raspberry Pi 모델 4는 이 학습 경로에 설명된 모든 명령을 수행할 수 있습니다. IoT 디바이스가 소프트웨어를 컴파일하거나를 실행할 수 없는 경우 로컬 호스트 컴퓨터에 필요한 컴파일러를 설치하여 소프트웨어를 빌드한 다음 IoT 디바이스로 전송해야 할 AWS Command Line Interface수 있습니다. 디바이스용 소프트웨어를 설치하고 빌드하는 방법에 대한 자세한 내용은 디바이스 소프트웨어의 설명서를 참조하세요.

**Topics**
+ [운영 체제 소프트웨어 업데이트](#iot-dc-prepare-device-sw-step1)
+ [필요한 애플리케이션 및 라이브러리 설치](#iot-dc-prepare-device-sw-step2)
+ [(선택 사항) microSD 카드 이미지 저장](#iot-dc-prepare-device-sw-step3)

## 운영 체제 소프트웨어 업데이트
<a name="iot-dc-prepare-device-sw-step1"></a>

이 절차는 운영 체제 소프트웨어를 업데이트합니다.

**Raspberry Pi에서 운영 체제 소프트웨어를 업데이트하려면**

로컬 호스트 컴퓨터의 터미널 창에서 다음 단계를 수행합니다.

1. 다음 명령을 입력하여 Raspberry Pi의 시스템 소프트웨어를 업데이트합니다.

   ```
   sudo apt-get -y update
   sudo apt-get -y upgrade
   sudo apt-get -y autoremove
   ```

1. Raspberry Pi의 로캘 및 시간대 설정을 업데이트합니다(선택 사항).

   이 명령을 입력하여 디바이스의 로캘 및 시간대 설정을 업데이트합니다.

   ```
   sudo raspi-config
   ```

   1. 디바이스의 로캘을 설정하려면

      1. **Raspberry Pi 소프트웨어 구성 도구(raspi-config)(Raspberry Pi Software Configuration Tool (raspi-config))** 화면에서 옵션 **5**를 선택합니다.

         **`5 Localisation Options Configure language and regional settings`**

         Tab 키를 사용하여 **<선택>(<Select>)**으로 이동하고 space bar를 누릅니다.

      1. 현지화 옵션 메뉴에서 **L1** 옵션을 선택합니다.

         **`L1 Locale Configure language and regional settings`**

         Tab 키를 사용하여 **<선택>(<Select>)**으로 이동하고 space bar를 누릅니다.

      1. 로캘 옵션 목록에서 화살표 키를 사용하여 스크롤하고 space bar를 사용하여 원하는 로캘을 표시하여 Raspberry Pi에 설치하려는 로캘을 선택합니다.

         미국에서는 **`en_US.UTF-8`**을 선택하는 것이 좋습니다.

      1. 디바이스의 로케일을 선택한 후 Tab 키를 사용하여 **<확인>(<OK>)**을 선택한 다음 space bar를 눌러 **로캘 구성(Configuring locales)** 확인 페이지를 표시합니다.

   1. 디바이스의 시간대를 설정하려면

      1. **raspi-config** 화면에서 옵션 **5**를 선택합니다.

         **`5 Localisation Options Configure language and regional settings`**

         Tab 키를 사용하여 **<선택>(<Select>)**으로 이동하고 space bar를 누릅니다.

      1. 현지화 옵션 메뉴에서 화살표 키를 사용하여 옵션 **L2**를 선택합니다.

         **`L2 time zone Configure time zone`**

         Tab 키를 사용하여 **<선택>(<Select>)**으로 이동하고 space bar를 누릅니다.

      1. **tzdata 구성(Configuring tzdata)** 메뉴의 목록에서 해당하는 지리적 영역을 선택합니다.

         Tab 키를 사용하여 **<확인>(<OK>)**으로 이동하고 space bar를 누릅니다.

      1. 도시 목록에서 화살표 키를 사용하여 해당 시간대의 도시를 선택합니다.

         시간대를 설정하려면 Tab 키를 사용하여 **<확인>(<OK>)**으로 이동하고 space bar를 누릅니다.

   1. 설정 업데이트가 완료되면 Tab 키를 사용하여 **<마침>(<Finish>)**으로 이동한 후 space bar를 눌러 **raspi-config** 앱을 닫습니다.

1. 이 명령을 입력하여 Raspberry Pi를 다시 시작합니다.

   ```
   sudo shutdown -r 0
   ```

1. Raspberry Pi가 다시 시작될 때까지 기다립니다.

1. Raspberry Pi를 다시 시작한 후 로컬 호스트 컴퓨터의 터미널 창을 Raspberry Pi에 다시 연결합니다.

이제 Raspberry Pi 시스템 소프트웨어가 구성되었으며 [필요한 애플리케이션 및 라이브러리 설치](#iot-dc-prepare-device-sw-step2)로 진행할 준비가 된 것입니다.

## 필요한 애플리케이션 및 라이브러리 설치
<a name="iot-dc-prepare-device-sw-step2"></a>

이 절차는 후속 튜토리얼에서 사용하는 애플리케이션 소프트웨어 및 라이브러리를 설치합니다.

Raspberry Pi를 사용 중이거나 IoT 디바이스에서 필요한 소프트웨어를 컴파일할 수 있는 경우 로컬 호스트 컴퓨터의 터미널 창에서 다음 단계를 수행합니다. 로컬 호스트 컴퓨터에서 IoT 디바이스용 소프트웨어를 컴파일해야 하는 경우 디바이스에서 이러한 단계를 수행하는 방법은 IoT 디바이스용 소프트웨어 설명서를 참조하세요.

**Raspberry Pi에 어플리케이션 소프트웨어 및 라이브러리를 설치하려면**

1. 이 명령을 입력하여 애플리케이션 소프트웨어 및 라이브러리를 설치합니다.

   ```
   sudo apt-get -y install build-essential libssl-dev cmake unzip git python3-pip
   ```

1. 이 명령을 입력하여 올바른 버전의 소프트웨어가 설치되었는지 확인합니다.

   ```
   gcc --version
   cmake --version
   openssl version
   git --version
   ```

1. 

   다음 버전의 애플리케이션 소프트웨어가 설치되어 있는지 확인합니다.
   + `gcc`: 9.3.0 이상
   + `cmake`: 3.10.x 이상
   + `OpenSSL`: 1.1.1 이상
   + `git`: 2.20.1 이상

Raspberry Pi에 필요한 어플리케이션 소프트웨어의 허용 가능한 버전이 있는 경우 [(선택 사항) microSD 카드 이미지 저장](#iot-dc-prepare-device-sw-step3)으로 진행할 준비가 된 것입니다.

## (선택 사항) microSD 카드 이미지 저장
<a name="iot-dc-prepare-device-sw-step3"></a>

이 학습 경로의 튜토리얼 전체에 Raspberry Pi의 microSD 카드 이미지 사본을 로컬 호스트 컴퓨터의 파일에 저장하는 절차가 있습니다. 권장되지만 필수 태스크는 아닙니다. 제안된 위치에 microSD 카드 이미지를 저장하면 이 학습 경로에서 저장 시점 이전의 절차를 건너뛸 수 있으므로 다시 시도해야 할 경우 시간을 절약할 수 있습니다. microSD 카드 이미지를 주기적으로 저장하지 않으면 microSD 카드가 손상되었거나 실수로 앱 또는 해당 설정을 잘못 구성한 경우 처음부터 학습 경로의 튜토리얼을 다시 시작해야 할 수 있습니다.

이 시점에서 Raspberry Pi의 microSD 카드에는 업데이트된 OS와 기본 어플리케이션 소프트웨어가 로드되어 있습니다. 지금 microSD 카드의 내용을 파일에 저장하면 이전 단계를 완료하는 데 걸리는 시간을 절약할 수 있습니다. 디바이스의 microSD 카드 이미지의 현재 이미지가 있으면 소프트웨어를 처음부터 설치하고 업데이트할 필요 없이 이 시점부터 시작하여 튜토리얼 또는 절차를 계속하거나 다시 시도할 수 있습니다.

**파일에 microSD 카드 이미지를 저장하려면**

1. 이 명령을 입력하여 Raspberry Pi를 종료합니다.

   ```
   sudo shutdown -h 0
   ```

1. Raspberry Pi가 완전히 종료되면 전원을 분리합니다.

1. Raspberry Pi에서 microSD 카드를 제거합니다.

1. 로컬 호스트 컴퓨터에서 

   1. microSD 카드를 삽입합니다.

   1. SD 카드 이미징 도구를 사용하여 microSD 카드의 이미지를 파일에 저장합니다.

   1. microSD 카드의 이미지를 저장한 후 로컬 호스트 컴퓨터에서 카드를 꺼냅니다.

1. Raspberry Pi의 전원을 분리한 상태에서 microSD 카드를 Raspberry Pi에 삽입합니다.

1. Raspberry Pi에 전원을 공급합니다.

1. 1분 정도 기다린 후 로컬 호스트 컴퓨터에서 Raspberry Pi에 연결된 로컬 호스트 컴퓨터의 터미널 창을 다시 연결한 다음 Raspberry Pi에 로그인합니다.

# 디바이스 테스트 및 Amazon CA 인증서 저장
<a name="iot-dc-prepare-device-test"></a>

이 섹션의 절차는 [이전 섹션에서](iot-dc-prepare-device-sw.md) 계속되어 AWS Command Line Interface 및 연결을 인증하는 데 사용되는 인증 기관 인증서를 설치합니다 AWS IoT Core.

이 섹션을 완료하면 Raspberry Pi에 AWS IoT Device Client를 설치하는 데 필요한 시스템 소프트웨어가 있고 인터넷에 연결되어 있음을 알 수 있습니다.

**필수 장비:**
+ [이전 섹션](iot-dc-prepare-device-sw.md)의 로컬 개발 및 테스트 환경
+ [이전 섹션](iot-dc-prepare-device-sw.md)에서 사용한 Raspberry Pi
+ [이전 섹션](iot-dc-prepare-device-sw.md)의 microSD 메모리 카드

**Topics**
+ [설치 AWS Command Line Interface](#iot-dc-prepare-device-test-step1)
+ [자격 AWS 계정 증명 구성](#iot-dc-prepare-device-test-step2)
+ [Amazon 루트 CA 인증서 다운로드](#iot-dc-prepare-device-test-step3)
+ [(선택 사항) microSD 카드 이미지 저장](#iot-dc-prepare-device-test-step4)

## 설치 AWS Command Line Interface
<a name="iot-dc-prepare-device-test-step1"></a>

이 절차에서는 Raspberry Pi AWS CLI 에를 설치합니다.

Raspberry Pi를 사용 중이거나 IoT 장치에서 소프트웨어를 컴파일할 수 있는 경우 로컬 호스트 컴퓨터의 터미널 창에서 다음 단계를 수행합니다. 로컬 호스트 컴퓨터에서 IoT 디바이스용 소프트웨어를 컴파일해야 하는 경우 IoT 디바이스에 대한 소프트웨어 설명서에서 필요한 라이브러리에 대한 정보를 검토합니다.

**Raspberry Pi AWS CLI 에를 설치하려면**

1. 다음 명령을 실행하여 AWS CLI를 다운로드하고 설치합니다.

   ```
   export PATH=$PATH:~/.local/bin # configures the path to include the directory with the AWS CLI
   git clone https://github.com/aws/aws-cli.git # download the AWS CLI code from GitHub
   cd aws-cli && git checkout v2 # go to the directory with the repo and checkout version 2
   pip3 install -r requirements.txt # install the prerequisite software
   ```

1. 이 명령을 실행하여를 설치합니다 AWS CLI. 이 명령을 완료하는 데 최대 15분이 소요될 수 있습니다.

   ```
   pip3 install . # install the AWS CLI 
   ```

1. 이 명령을 실행하여 올바른 버전의가 설치 AWS CLI 되었는지 확인합니다.

   ```
   aws --version
   ```

   의 버전은 2.2 이상이어야 AWS CLI 합니다.

에 현재 버전이 AWS CLI 표시되면 로 계속 진행할 준비가 된 것입니다[자격 AWS 계정 증명 구성](#iot-dc-prepare-device-test-step2).

## 자격 AWS 계정 증명 구성
<a name="iot-dc-prepare-device-test-step2"></a>

이 절차에서는 자격 AWS 계정 증명을 얻고 Raspberry Pi에서 사용할 자격 증명을 추가합니다.

**디바이스에 AWS 계정 자격 증명을 추가하려면**

1. 에서 **액세스 키 ID** 및 **보안 액세스 키를** 가져 AWS 계정 와 디바이스 AWS CLI 에서를 인증합니다.

    AWS IAM을 처음 사용하는 경우 [ https://aws.amazon.com/premiumsupport/knowledge-center/create-access-key/ ](https://aws.amazon.com/premiumsupport/knowledge-center/create-access-key/) 콘솔에서 실행하여 디바이스에서 사용할 IAM 자격 증명을 AWS 생성하는 AWS 프로세스를 설명합니다.

1. Raspberry Pi에 연결된 로컬 호스트 컴퓨터의 터미널 창에서 디바이스의 **액세스 키 ID(Access Key ID)** 및 **비밀 액세스 키(Secret Access Key)** 자격 증명을 사용하여 다음을 수행합니다.

   1. 다음 명령을 사용하여 AWS 구성 앱을 실행합니다.

      ```
      aws configure
      ```

   1. 메시지가 표시되면 자격 증명 및 구성 정보를 입력합니다.

      ```
      AWS Access Key ID: your Access Key ID
      AWS Secret Access Key: your Secret Access Key
      Default region name: your AWS 리전 code
      Default output format: json
      ```

1. 이 명령을 실행하여 AWS 계정 및 AWS IoT Core 엔드포인트에 대한 디바이스의 액세스를 테스트합니다.

   ```
   aws iot describe-endpoint --endpoint-type iot:Data-ATS
   ```

   이 예제와 같이 AWS 계정특정 AWS IoT 데이터 엔드포인트를 반환해야 합니다.

   ```
   {
       "endpointAddress": "a3EXAMPLEffp-ats.iot.us-west-2.amazonaws.com"
   }
   ```

 AWS 계정특정 AWS IoT 데이터 엔드포인트가 표시되면 Raspberry Pi에를 계속할 수 있는 연결 및 권한이 있습니다[Amazon 루트 CA 인증서 다운로드](#iot-dc-prepare-device-test-step3).

**중요**  
이제 자격 AWS 계정 증명이 Raspberry Pi의 microSD 카드에 저장됩니다. 이렇게 하면 향후 사용자 및이 자습서에서 생성할 소프트웨어와의 상호 작용이 AWS 쉬워지지만 기본적으로이 단계 이후에 만든 microSD 카드 이미지에도 저장되고 복제됩니다.  
자격 AWS 계정 증명의 보안을 보호하려면 microSD 카드 이미지를 더 저장하기 전에를 `aws configure` 다시 실행하고 **액세스 키 ID** 및 **보안 액세스 키**에 임의의 문자를 입력하여 자격 증명을 삭제하여 자격 AWS 계정 증명이 손상되지 않도록 하는 것이 좋습니다.  
실수로 자격 증명을 저장한 경우 AWS IAM 콘솔에서 자격 AWS 계정 증명을 비활성화할 수 있습니다.

## Amazon 루트 CA 인증서 다운로드
<a name="iot-dc-prepare-device-test-step3"></a>

이 절차는 Amazon 루트 인증 기관(CA)의 인증서 사본을 다운로드하고 저장합니다. 이 인증서를 다운로드하면 다음 튜토리얼에서 사용할 수 있도록 저장되며 AWS 서비스와의 디바이스 연결도 테스트합니다.

**Amazon 루트 CA 인증서를 다운로드하고 저장하려면**

1. 이 명령을 실행하여 인증서 디렉터리를 생성합니다.

   ```
   mkdir ~/certs
   ```

1. 이 명령을 실행하여 Amazon Root CA 인증서를 다운로드합니다.

   ```
   curl -o ~/certs/AmazonRootCA1.pem https://www.amazontrust.com/repository/AmazonRootCA1.pem
   ```

1. 이 명령을 실행하여 인증서 디렉터리와 해당 파일에 대한 액세스를 설정합니다.

   ```
   chmod 745 ~
   chmod 700 ~/certs
   chmod 644 ~/certs/AmazonRootCA1.pem
   ```

1. 이 명령을 실행하여 새 디렉터리에서 CA 인증서 파일을 확인합니다.

   ```
   ls -l ~/certs
   ```

   다음과 같은 항목이 표시되어야 합니다. 날짜와 시간은 다릅니다. 그러나 파일 크기와 기타 모든 정보는 여기에 표시된 것과 동일해야 합니다.

   ```
   -rw-r--r-- 1 pi pi 1188 Oct 28 13:02 AmazonRootCA1.pem
   ```

   파일 크기가 `1188`이 아닌 경우 **curl** 명령 파라미터를 확인합니다. 잘못된 파일을 다운로드했을 수 있습니다.

## (선택 사항) microSD 카드 이미지 저장
<a name="iot-dc-prepare-device-test-step4"></a>

이 시점에서 Raspberry Pi의 microSD 카드에는 업데이트된 OS와 기본 어플리케이션 소프트웨어가 로드되어 있습니다.

**파일에 microSD 카드 이미지를 저장하려면**

1. 로컬 호스트 컴퓨터의 터미널 창에서 AWS 자격 증명을 지웁니다.

   1. 다음 명령을 사용하여 AWS 구성 앱을 실행합니다.

      ```
      aws configure
      ```

   1. 메시지가 나타나면 자격 증명을 바꿉니다. **Enter** 키를 눌러 **기본 영역 이름(Default region name)**과 **기본 출력 형식(Default output format)**을 그대로 둘 수 있습니다.

      ```
      AWS Access Key ID [****************YT2H]: XYXYXYXYX
      AWS Secret Access Key [****************9plH]: XYXYXYXYX
      Default region name [us-west-2]: 
      Default output format [json]:
      ```

1. 이 명령을 입력하여 Raspberry Pi를 종료합니다.

   ```
   sudo shutdown -h 0
   ```

1. Raspberry Pi가 완전히 종료되면 전원 커넥터를 분리합니다.

1. 디바이스에서 microSD 카드를 분리합니다.

1. 로컬 호스트 컴퓨터에서 

   1. microSD 카드를 삽입합니다.

   1. SD 카드 이미징 도구를 사용하여 microSD 카드의 이미지를 파일에 저장합니다.

   1. microSD 카드의 이미지를 저장한 후 로컬 호스트 컴퓨터에서 카드를 꺼냅니다.

1. Raspberry Pi의 전원을 분리한 상태에서 microSD 카드를 Raspberry Pi에 삽입합니다.

1. 디바이스에 전원을 공급합니다.

1. 약 1분 후 로컬 호스트 컴퓨터에서 터미널 창 세션을 다시 시작하고 디바이스에 로그인합니다.

   **자격 AWS 계정 증명을 아직 다시 입력하지 마세요.**

다시 시작하고 Raspberry Pi에 로그인하면 [자습서: AWS IoT Device Client 설치 및 구성](iot-dc-install-dc.md)으로 진행할 준비가 된 것입니다.

# 자습서: AWS IoT Device Client 설치 및 구성
<a name="iot-dc-install-dc"></a>

이 자습서에서는 AWS IoT Device Client의 설치 및 구성과이 데모 및 기타 데모에서 사용할 AWS IoT 리소스 생성을 안내합니다.

**이 자습서를 시작하려면:**
+ [이전 튜토리얼](iot-dc-prepare-device.md)의 로컬 호스트 컴퓨터와 Raspberry Pi를 준비합니다.

이 자습서는 완료하는 데 약 90분이 소요됩니다.

**이 주제를 마치면**
+ IoT 디바이스는 다른 AWS IoT Device Client 데모에서 바로 사용할 수 있습니다.
+ IoT 디바이스를 프로비저닝했습니다 AWS IoT Core.
+ 디바이스에 AWS IoT Device Client를 다운로드하고 설치했습니다.
+ 이후 튜토리얼에서 사용할 수 있는 디바이스의 microSD 카드 이미지를 저장했습니다.

**필수 장비:**
+ [이전 섹션](iot-dc-prepare-device-test.md)의 로컬 개발 및 테스트 환경
+ [이전 섹션](iot-dc-prepare-device-test.md)에서 사용한 Raspberry Pi
+ [이전 섹션](iot-dc-prepare-device-test.md)에서 사용한 Raspberry Pi의 microSD 메모리 카드

**Topics**
+ [AWS IoT Device Client 다운로드 및 저장](iot-dc-install-download.md)
+ [에서 Raspberry Pi 프로비저닝 AWS IoT](iot-dc-install-provision.md)
+ [연결을 테스트하도록 AWS IoT Device Client 구성](iot-dc-install-configure.md)

# AWS IoT Device Client 다운로드 및 저장
<a name="iot-dc-install-download"></a>

이 섹션의 절차에서는 AWS IoT Device Client를 다운로드하고 컴파일한 다음 Raspberry Pi에 설치합니다. 설치를 테스트한 후 나중에 튜토리얼을 다시 시도할 때 사용할 수 있도록 Raspberry Pi의 microSD 카드 이미지를 저장할 수 있습니다.

**Topics**
+ [AWS IoT Device Client 다운로드 및 빌드](#iot-dc-install-dc-download)
+ [튜토리얼에서 사용하는 디렉터리 생성](#iot-dc-install-dc-files)
+ [(선택 사항) microSD 카드 이미지 저장](#iot-dc-install-dc-save)

## AWS IoT Device Client 다운로드 및 빌드
<a name="iot-dc-install-dc-download"></a>

이 절차에서는 Raspberry Pi에 AWS IoT Device Client를 설치합니다.

Raspberry Pi에 연결된 로컬 호스트 컴퓨터의 터미널 창에서 다음 명령을 수행합니다.

**Raspberry Pi에 AWS IoT Device Client를 설치하려면**

1. 다음 명령을 입력하여 Raspberry Pi에서 AWS IoT Device Client를 다운로드하고 빌드합니다.

   ```
   cd ~
   git clone https://github.com/awslabs/aws-iot-device-client aws-iot-device-client
   mkdir ~/aws-iot-device-client/build && cd ~/aws-iot-device-client/build
   cmake ../
   ```

1. 이 명령을 실행하여 AWS IoT Device Client를 빌드합니다. 이 명령을 완료하는 데 최대 15분이 소요될 수 있습니다.

   ```
   cmake --build . --target aws-iot-device-client
   ```

    AWS IoT Device Client 컴파일로 표시되는 경고 메시지는 무시할 수 있습니다.

   이 자습서는 **gcc**2021년 10월 30일 Raspberry Pi OS(bullseye)의 , 버전(Raspbian 10.2.1-6\$1rpi1) 10.2.1 20210110, 2021년 5월 7일 Raspberry Pi OS(buster)의 **gcc**버전(Raspbian 8.3.0-6\$1rpi1) 8.3.0에 구축된 AWS IoT Device Client로 테스트되었습니다.

1.  AWS IoT Device Client 빌드가 완료되면이 명령을 실행하여 테스트합니다.

   ```
   ./aws-iot-device-client --help
   ```

 AWS IoT Device Client에 대한 명령줄 도움말이 표시되면 AWS IoT Device Client가 성공적으로 빌드되었으며 사용할 준비가 된 것입니다.

## 튜토리얼에서 사용하는 디렉터리 생성
<a name="iot-dc-install-dc-files"></a>

이 절차에서는 이 학습 경로의 튜토리얼에서 사용하는 파일을 저장하는 데 사용할 디렉터리를 Raspberry Pi에 생성합니다.

**이 학습 경로의 튜토리얼에서 사용하는 디렉터리를 생성하려면**

1. 이 명령을 실행하여 필요한 디렉터리를 생성합니다.

   ```
   mkdir ~/dc-configs
   mkdir ~/policies
   mkdir ~/messages
   mkdir ~/certs/testconn
   mkdir ~/certs/pubsub
   mkdir ~/certs/jobs
   ```

1. 이 명령을 실행하여 새 디렉터리에 대한 권한을 설정합니다.

   ```
   chmod 745 ~
   chmod 700 ~/certs/testconn
   chmod 700 ~/certs/pubsub
   chmod 700 ~/certs/jobs
   ```

이러한 디렉터리를 생성하고 해당 권한을 설정한 후 [(선택 사항) microSD 카드 이미지 저장](#iot-dc-install-dc-save)으로 진행합니다.

## (선택 사항) microSD 카드 이미지 저장
<a name="iot-dc-install-dc-save"></a>

이때 Raspberry Pi의 microSD 카드에는 업데이트된 OS, 기본 애플리케이션 소프트웨어 및 AWS IoT Device Client가 있습니다.

이 연습과 튜토리얼을 다시 시도하기 위해 돌아와서 이 절차에서 저장한 microSD 카드 이미지를 새 microSD 카드에 기록하여 이전 절차를 건너뛰고 [에서 Raspberry Pi 프로비저닝 AWS IoT](iot-dc-install-provision.md)부터 튜토리얼을 계속할 수 있습니다.

**파일에 microSD 카드 이미지를 저장하려면**

Raspberry Pi에 연결된 로컬 호스트 컴퓨터의 터미널 창에서

1. 자격 AWS 계정 증명이 저장되지 않았는지 확인합니다.

   1. 다음 명령을 사용하여 AWS 구성 앱을 실행합니다.

      ```
      aws configure
      ```

   1. 자격 증명이 저장된 경우(프롬프트에 표시되는 경우) 여기에 표시된 대로 메시지가 나타나면 **XYXYXYXYX** 문자열을 입력합니다. **기본 리전 이름(Default region name)**과 **기본 출력 형식(Default output format)**을 비워 둡니다.

      ```
      AWS Access Key ID [****************YXYX]: XYXYXYXYX
      AWS Secret Access Key [****************YXYX]: XYXYXYXYX
      Default region name: 
      Default output format:
      ```

1. 이 명령을 입력하여 Raspberry Pi를 종료합니다.

   ```
   sudo shutdown -h 0
   ```

1. Raspberry Pi가 완전히 종료되면 전원 커넥터를 분리합니다.

1. 디바이스에서 microSD 카드를 분리합니다.

1. 로컬 호스트 컴퓨터에서 

   1. microSD 카드를 삽입합니다.

   1. SD 카드 이미징 도구를 사용하여 microSD 카드의 이미지를 파일에 저장합니다.

   1. microSD 카드의 이미지를 저장한 후 로컬 호스트 컴퓨터에서 카드를 꺼냅니다.

[에서 Raspberry Pi 프로비저닝 AWS IoT](iot-dc-install-provision.md)에서 이 microSD 카드를 계속 사용할 수 있습니다.

# 에서 Raspberry Pi 프로비저닝 AWS IoT
<a name="iot-dc-install-provision"></a>

이 섹션의 절차는 및 AWS IoT Device Client가 AWS CLI 설치된 저장된 microSD 이미지로 시작하고 Raspberry Pi를 프로비저닝하는 AWS IoT 리소스 및 디바이스 인증서를 생성합니다 AWS IoT.

## Raspberry Pi에 microSD 카드를 설치합니다.
<a name="iot-dc-install-dc-restore"></a>

이 절차에서는 필요한 소프트웨어가 로드되고 Raspberry Pi에 구성된 microSD 카드를 설치하고이 학습 경로의 자습서를 계속할 수 AWS 계정 있도록를 구성합니다.

이 학습 경로의 연습 및 튜토리얼에 필요한 소프트웨어가 있는 [(선택 사항) microSD 카드 이미지 저장](iot-dc-install-download.md#iot-dc-install-dc-save)의 microSD 카드를 사용합니다.

**Raspberry Pi에 microSD 카드를 설치하려면**

1. Raspberry Pi의 전원을 분리한 상태에서 microSD 카드를 Raspberry Pi에 삽입합니다.

1. Raspberry Pi에 전원을 공급합니다.

1. 약 1분 후 로컬 호스트 컴퓨터에서 터미널 창 세션을 다시 시작하고 Raspberry Pi에 로그인합니다.

1. 로컬 호스트 컴퓨터의 터미널 창에서 Raspberry Pi의 **액세스 키 ID(Access Key ID)** 및 **비밀 액세스 키(Secret Access Key)** 자격 증명을 사용하여

   1. 다음 명령을 사용하여 AWS 구성 앱을 실행합니다.

      ```
      aws configure
      ```

   1. 메시지가 표시되면 자격 AWS 계정 증명 및 구성 정보를 입력합니다.

      ```
      AWS Access Key ID [****************YXYX]: your Access Key ID
      AWS Secret Access Key [****************YXYX]: your Secret Access Key
      Default region name [us-west-2]: your AWS 리전 code
      Default output format [json]: json
      ```

자격 AWS 계정 증명을 복원한 후에는 로 계속 진행할 준비가 된 것입니다[에서 디바이스 프로비저닝 AWS IoT Core](#iot-dc-install-dc-provision).

## 에서 디바이스 프로비저닝 AWS IoT Core
<a name="iot-dc-install-dc-provision"></a>

이 섹션의 절차에서는 Raspberry Pi를 프로비저닝하는 AWS IoT 리소스를 생성합니다 AWS IoT. 이러한 리소스를 생성할 때 다양한 정보를 기록하라는 메시지가 나타납니다. 이 정보는 다음 절차에서 AWS IoT Device Client 구성에 사용됩니다.

Raspberry Pi가 함께 작동하려면 프로비저닝해야 AWS IoT합니다. 프로비저닝은 Raspberry Pi를 IoT 디바이스로 지원하는 데 필요한 AWS IoT 리소스를 생성하고 구성하는 프로세스입니다.

Raspberry Pi의 전원을 켜고 다시 시작한 상태에서 로컬 호스트 컴퓨터의 터미널 창을 Raspberry Pi에 연결하고 이 절차를 완료합니다.

**Topics**
+ [디바이스 인증서 파일 생성 및 다운로드](#iot-dc-install-dc-provision-certs)
+ [AWS IoT 리소스 생성](#iot-dc-install-dc-provision-resources)

### 디바이스 인증서 파일 생성 및 다운로드
<a name="iot-dc-install-dc-provision-certs"></a>

이 절차는 이 데모에 대한 디바이스 인증서 파일을 생성합니다.

**Raspberry Pi에 대한 디바이스 인증서 파일을 생성하고 다운로드하려면**

1. 로컬 호스트 컴퓨터의 터미널 창에서 이 명령을 입력하여 디바이스에 대한 디바이스 인증서 파일을 생성합니다.

   ```
   mkdir ~/certs/testconn
   aws iot create-keys-and-certificate \
   --set-as-active \
   --certificate-pem-outfile "~/certs/testconn/device.pem.crt" \
   --public-key-outfile "~/certs/testconn/public.pem.key" \
   --private-key-outfile "~/certs/testconn/private.pem.key"
   ```

   이 명령은 다음과 같은 응답을 반환합니다. 나중에 사용하기 위해 `certificateArn` 값을 적어 둡니다.

   ```
   {
       "certificateArn": "arn:aws:iot:us-west-2:57EXAMPLE833:cert/76e7e4edb3e52f52334be2f387a06145b2aa4c7fcd810f3aea2d92abc227d269",
       "certificateId": "76e7e4edb3e52f5233EXAMPLE7a06145b2aa4c7fcd810f3aea2d92abc227d269",
       "certificatePem": "-----BEGIN CERTIFICATE-----\nMIIDWTCCAkGgAwIBAgI_SHORTENED_FOR_EXAMPLE_Lgn4jfgtS\n-----END CERTIFICATE-----\n",
       "keyPair": {
           "PublicKey": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BA_SHORTENED_FOR_EXAMPLE_ImwIDAQAB\n-----END PUBLIC KEY-----\n",
           "PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\nMIIEowIBAAKCAQE_SHORTENED_FOR_EXAMPLE_T9RoDiukY\n-----END RSA PRIVATE KEY-----\n"
       }
   }
   ```

1. 이 명령을 입력하여 인증서 디렉터리와 해당 파일에 대한 권한을 설정합니다.

   ```
   chmod 745 ~
   chmod 700 ~/certs/testconn
   chmod 644 ~/certs/testconn/*
   chmod 600 ~/certs/testconn/private.pem.key
   ```

1. 이 명령을 실행하여 인증서 디렉터리 및 파일에 대한 권한을 검토합니다.

   ```
   ls -l ~/certs/testconn
   ```

   명령의 출력은 파일 날짜와 시간이 다르다는 점을 제외하고 여기에 표시되는 것과 같아야 합니다.

   ```
   -rw-r--r-- 1 pi pi 1220 Oct 28 13:02 device.pem.crt
   -rw------- 1 pi pi 1675 Oct 28 13:02 private.pem.key
   -rw-r--r-- 1 pi pi  451 Oct 28 13:02 public.pem.key
   ```

이 시점에서 Raspberry Pi에 디바이스 인증서 파일이 설치되어 있고 [AWS IoT 리소스 생성](#iot-dc-install-dc-provision-resources)을 계속할 수 있습니다.

### AWS IoT 리소스 생성
<a name="iot-dc-install-dc-provision-resources"></a>

이 절차에서는 디바이스가 AWS IoT 기능 및 서비스에 액세스하는 데 필요한 리소스를 생성 AWS IoT 하여에 디바이스를 프로비저닝합니다.

**에서 디바이스를 프로비저닝하려면 AWS IoT**

1. 로컬 호스트 컴퓨터의 터미널 창에서 이 명령을 입력하여 AWS 계정의 디바이스 데이터 엔드포인트 주소를 가져옵니다.

   ```
   aws iot describe-endpoint --endpoint-type IoT:Data-ATS
   ```

   이전 단계의 명령에서 다음과 같은 응답이 반환됩니다. 나중에 사용하기 위해 `endpointAddress` 값을 적어 둡니다.

   ```
   {
       "endpointAddress": "a3qjEXAMPLEffp-ats.iot.us-west-2.amazonaws.com"
   }
   ```

1. Raspberry Pi에 대한 AWS IoT 사물 리소스를 생성하려면이 명령을 입력합니다.

   ```
   aws iot create-thing --thing-name "DevCliTestThing"
   ```

    AWS IoT 사물 리소스가 생성된 경우 명령은 이와 같은 응답을 반환합니다.

   ```
   {
       "thingName": "DevCliTestThing",
       "thingArn": "arn:aws:iot:us-west-2:57EXAMPLE833:thing/DevCliTestThing",
       "thingId": "8ea78707-32c3-4f8a-9232-14bEXAMPLEfd"
   }
   ```

1. 터미널 창에서

   1. `nano` 등의 텍스트 편집기를 엽니다.

   1. 이 JSON 정책 문서를 복사하여 열려 있는 텍스트 편집기에 붙여 넣습니다.  
****  

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [
              {
                  "Effect": "Allow",
                  "Action": [
                      "iot:Publish",
                      "iot:Subscribe",
                      "iot:Receive",
                      "iot:Connect"
                  ],
                  "Resource": [
                      "*"
                  ]
              }
          ]
      }
      ```
**참고**  
이 정책 문서는 모든 리소스에 연결, 수신, 게시 및 구독을 위한 권한을 충분히 부여합니다. 일반적으로 정책은 특정 리소스에만 특정 작업을 수행할 수 있는 권한만 부여합니다. 그러나 초기 디바이스 연결 테스트의 경우 이 테스트 중 액세스 문제 발생 가능성을 최소화하기 위해 이 지나치게 일반적이고 허용적인 정책이 사용됩니다. 후속 튜토리얼에서는 정책 설계의 더 나은 사례를 보여주기 위해 보다 좁은 범위의 정책 문서를 사용할 것입니다.

   1. 텍스트 편집기에서 파일을 **\$1/policies/dev\$1cli\$1test\$1thing\$1policy.json**으로 저장합니다.

1. 이전 단계의 정책 문서를 사용하여 AWS IoT 정책을 생성하려면이 명령을 실행합니다.

   ```
   aws iot create-policy \
   --policy-name "DevCliTestThingPolicy" \
   --policy-document "file://~/policies/dev_cli_test_thing_policy.json"
   ```

   정책이 생성되면 명령에서 다음과 같은 응답을 반환합니다.

   ```
   {
       "policyName": "DevCliTestThingPolicy",
       "policyArn": "arn:aws:iot:us-west-2:57EXAMPLE833:policy/DevCliTestThingPolicy",
       "policyDocument": "{\n    \"Version\": \"2012-10-17\",		 	 	 \n    \"Statement\": [\n        {\n            \"Effect\": \"Allow\",\n            \"Action\": [\n                \"iot:Publish\",\n                \"iot:Subscribe\",\n                \"iot:Receive\",\n                \"iot:Connect\"\n            ],\n            \"Resource\": [\n                \"*\"\n            ]\n        }\n    ]\n}\n",
       "policyVersionId": "1"
   }
   ```

1. 이 명령을 실행하여 디바이스 인증서에 정책을 연결합니다. `certificateArn`을 이전에 저장한 `certificateArn` 값으로 바꿉니다.

   ```
   aws iot attach-policy \
   --policy-name "DevCliTestThingPolicy" \
   --target "certificateArn"
   ```

   성공한 경우 이 명령은 아무 것도 반환하지 않습니다.

1. 이 명령을 실행하여 디바이스 인증서를 AWS IoT 사물 리소스에 연결합니다. `certificateArn`을 이전에 저장한 `certificateArn` 값으로 바꿉니다.

   ```
   aws iot attach-thing-principal \
   --thing-name "DevCliTestThing" \
   --principal "certificateArn"
   ```

   성공한 경우 이 명령은 아무 것도 반환하지 않습니다.

에서 디바이스를 성공적으로 프로비저닝 AWS IoT했으면 로 계속 진행할 준비가 된 것입니다[연결을 테스트하도록 AWS IoT Device Client 구성](iot-dc-install-configure.md).

# 연결을 테스트하도록 AWS IoT Device Client 구성
<a name="iot-dc-install-configure"></a>

이 섹션의 절차는 Raspberry Pi에서 MQTT 메시지를 게시하도록 AWS IoT Device Client를 구성합니다.

**Topics**
+ [구성 파일 생성](#iot-dc-install-dc-configure-step1)
+ [MQTT 테스트 클라이언트 열기](#iot-dc-install-dc-configure-step2)
+ [AWS IoT 디바이스 클라이언트 실행](#iot-dc-install-dc-configure-step3)

## 구성 파일 생성
<a name="iot-dc-install-dc-configure-step1"></a>

이 절차에서는 AWS IoT Device Client를 테스트하는 구성 파일을 생성합니다.

**AWS IoT Device Client를 테스트하기 위한 구성 파일을 생성하려면**
+ Raspberry Pi에 연결된 로컬 호스트 컴퓨터의 터미널 창에서

  1. 이 명령을 입력하여 구성 파일에 대한 디렉터리를 생성하고 디렉터리에 대한 권한을 설정합니다.

     ```
     mkdir ~/dc-configs
     chmod 745 ~/dc-configs
     ```

  1. `nano` 등의 텍스트 편집기를 엽니다.

  1. 이 JSON 문서를 복사하여 열려 있는 텍스트 편집기에 붙여 넣습니다.

     ```
     {
       "endpoint": "a3qEXAMPLEaffp-ats.iot.us-west-2.amazonaws.com",
       "cert": "~/certs/testconn/device.pem.crt",
       "key": "~/certs/testconn/private.pem.key",
       "root-ca": "~/certs/AmazonRootCA1.pem",
       "thing-name": "DevCliTestThing",
       "logging": {
         "enable-sdk-logging": true,
         "level": "DEBUG",
         "type": "STDOUT",
         "file": ""
       },
       "jobs": {
         "enabled": false,
         "handler-directory": ""
       },
       "tunneling": {
         "enabled": false
       },
       "device-defender": {
         "enabled": false,
         "interval": 300
       },
       "fleet-provisioning": {
         "enabled": false,
         "template-name": "",
         "template-parameters": "",
         "csr-file": "",
         "device-key": ""
       },
       "samples": {
         "pub-sub": {
           "enabled": true,
           "publish-topic": "test/dc/pubtopic",
           "publish-file": "",
           "subscribe-topic": "test/dc/subtopic",
           "subscribe-file": ""
         }
       },
       "config-shadow": {
         "enabled": false
       },
       "sample-shadow": {
         "enabled": false,
         "shadow-name": "",
         "shadow-input-file": "",
         "shadow-output-file": ""
       }
     }
     ```

  1. *엔드포인트* 값을에서 찾 AWS 계정 은의 디바이스 데이터 엔드포인트로 바꿉니다[에서 디바이스 프로비저닝 AWS IoT Core](iot-dc-install-provision.md#iot-dc-install-dc-provision).

  1. 텍스트 편집기에서 파일을 **\$1/dc-configs/dc-testconn-config.json**으로 저장합니다.

  1. 이 명령을 실행하여 새로운 구성 파일에 대한 권한을 설정합니다.

     ```
     chmod 644 ~/dc-configs/dc-testconn-config.json
     ```

파일을 저장한 후에는 [MQTT 테스트 클라이언트 열기](#iot-dc-install-dc-configure-step2)로 진행할 준비가 된 것입니다.

## MQTT 테스트 클라이언트 열기
<a name="iot-dc-install-dc-configure-step2"></a>

이 절차는 AWS IoT 콘솔에서 **MQTT 테스트 클라이언트**가 실행될 때 AWS IoT Device Client가 게시하는 MQTT 메시지를 구독하도록 준비합니다.

**모든 MQTT 메시지를 구독하도록 **MQTT 테스트 클라이언트(MQTT test client)**를 준비하려면**

1. 로컬 호스트 컴퓨터의 [AWS IoT 콘솔](https://console.aws.amazon.com//iot/home#/test)에서 **MQTT 테스트 클라이언트(MQTT test client)**를 선택합니다.

1. **주제 구독** 탭의 **주제 필터**에 **\$1**(파운드 기호 1개)를 입력하고 **구독**을 선택하여 모든 MQTT 주제를 구독합니다.

1. **구독(Subscriptions)** 레이블 아래에 **\$1**(파운드 기호 1개)가 표시되는지 확인합니다.

[AWS IoT 디바이스 클라이언트 실행](#iot-dc-install-dc-configure-step3)으로 진행하면서 **MQTT 테스트 클라이언트(MQTT test client)**가 열려 있는 창을 그대로 둡니다.

## AWS IoT 디바이스 클라이언트 실행
<a name="iot-dc-install-dc-configure-step3"></a>

이 절차는 AWS IoT Device Client를 실행하여 MQTT **테스트 클라이언트가 수신하고 표시하는 단일 MQTT** 메시지를 게시합니다.

**AWS IoT Device Client에서 MQTT 메시지를 보내려면**

1. 이 절차를 수행하는 동안 Raspberry Pi에 연결된 터미널 창과 **MQTT 테스트 클라이언트(MQTT test client)**가 있는 창이 모두 표시되는지 확인합니다.

1. 터미널 창에서 다음 명령을 입력하여에서 생성된 구성 파일을 사용하여 AWS IoT Device Client를 실행합니다[구성 파일 생성](#iot-dc-install-dc-configure-step1).

   ```
   cd ~/aws-iot-device-client/build
   ./aws-iot-device-client --config-file ~/dc-configs/dc-testconn-config.json
   ```

   터미널 창에서 AWS IoT Device Client는 정보 메시지와 실행 시 발생하는 오류를 표시합니다.

   터미널 창에 오류가 표시되지 않으면 **MQTT 테스트 클라이언트(MQTT test client)**를 검토합니다.

1. **MQTT 테스트 클라이언트**의 구독 창에서 `test/dc/pubtopic` 메시지 주제로 *Hello World\$1* 메시지가 전송되었음을 확인할 수 있습니다.

1.  AWS IoT Device Client에 오류가 표시되지 않고 *Hello World\$1*가 **MQTT 테스트 클라이언트**의 `test/dc/pubtopic` 메시지로 전송된 것을 볼 수 있는 경우 성공적인 연결을 입증한 것입니다.

1. 터미널 창에서 **^C** (Ctrl-C)를 입력하여 AWS IoT Device Client를 중지합니다.

 AWS IoT 디바이스 클라이언트가 Raspberry Pi에서 올바르게 실행되고 있고와 통신할 수 있음을 입증한 후에는 로 계속 AWS IoT진행할 수 있습니다[자습서: AWS IoT Device Client와의 MQTT 메시지 통신 시연](iot-dc-testconn.md).

# 자습서: AWS IoT Device Client와의 MQTT 메시지 통신 시연
<a name="iot-dc-testconn"></a>

이 자습서에서는 AWS IoT Device Client가 IoT 솔루션에서 일반적으로 사용되는 MQTT 메시지를 구독하고 게시하는 방법을 보여줍니다.

**이 자습서를 시작하려면:**
+ [이전 섹션](iot-dc-install-dc.md)에서 사용한 대로 로컬 호스트 컴퓨터와 Raspberry Pi를 구성합니다.

   AWS IoT Device Client를 설치한 후 microSD 카드 이미지를 저장한 경우 해당 이미지와 함께 microSD 카드를 Raspberry Pi와 함께 사용할 수 있습니다.
+ 이전에이 데모를 실행한 적이 있는 경우 [2단계: AWS IoT Device Client로 데모를 빌드한 AWS 계정 후 정리](iot-dc-cleanup.md#iot-dc-cleanup-cloud)를 검토하여 이전 실행에서 생성한 모든 AWS IoT 리소스를 삭제하여 중복 리소스 오류를 방지합니다.

이 자습서는 완료하는 데 약 45분이 소요됩니다.

**이 주제를 마치면**
+ IoT 디바이스가의 MQTT 메시지를 구독 AWS IoT 하고 MQTT 메시지를 게시할 수 있는 다양한 방법을 보여드렸습니다 AWS IoT.

**필수 장비:**
+ [이전 섹션](iot-dc-install-dc.md)의 로컬 개발 및 테스트 환경
+ [이전 섹션](iot-dc-install-dc.md)에서 사용한 Raspberry Pi
+ [이전 섹션](iot-dc-install-dc.md)에서 사용한 Raspberry Pi의 microSD 메모리 카드

**Topics**
+ [MQTT 메시지 통신 시연을 위해 Raspberry Pi 준비](iot-dc-testconn-provision.md)
+ [AWS IoT Device Client를 사용하여 메시지 게시 시연](iot-dc-testconn-publish.md)
+ [AWS IoT Device Client를 사용하여 메시지 구독 시연](iot-dc-testconn-subscribe.md)

# MQTT 메시지 통신 시연을 위해 Raspberry Pi 준비
<a name="iot-dc-testconn-provision"></a>

이 절차에서는 AWS IoT 및 Raspberry Pi에 리소스를 생성하여 AWS IoT Device Client를 사용한 MQTT 메시지 통신을 보여줍니다.

**Topics**
+ [인증서 파일을 생성하여 MQTT 통신을 시연합니다.](#iot-dc-testconn-provision-certs)
+ [MQTT 통신을 시연하기 위해 디바이스 프로비저닝](#iot-dc-testconn-provision-aws)
+ [MQTT 통신을 보여주도록 AWS IoT Device Client 구성 파일 및 MQTT 테스트 클라이언트 구성](#iot-dc-testconn-provision-dc-config)

## 인증서 파일을 생성하여 MQTT 통신을 시연합니다.
<a name="iot-dc-testconn-provision-certs"></a>

이 절차는 이 데모에 대한 디바이스 인증서 파일을 생성합니다.

**Raspberry Pi에 대한 디바이스 인증서 파일을 생성하고 다운로드하려면**



1. 로컬 호스트 컴퓨터의 터미널 창에서 다음 명령을 입력하여 디바이스에 대한 디바이스 인증서 파일을 만듭니다.

   ```
   mkdir ~/certs/pubsub
   aws iot create-keys-and-certificate \
   --set-as-active \
   --certificate-pem-outfile "~/certs/pubsub/device.pem.crt" \
   --public-key-outfile "~/certs/pubsub/public.pem.key" \
   --private-key-outfile "~/certs/pubsub/private.pem.key"
   ```

   이 명령은 다음과 같은 응답을 반환합니다. 나중에 사용할 수 있도록 `certificateArn` 값을 저장합니다.

   ```
   {
   "certificateArn": "arn:aws:iot:us-west-2:57EXAMPLE833:cert/76e7e4edb3e52f52334be2f387a06145b2aa4c7fcd810f3aea2d92abc227d269",
   "certificateId": "76e7e4edb3e52f5233EXAMPLE7a06145b2aa4c7fcd810f3aea2d92abc227d269",
   "certificatePem": "-----BEGIN CERTIFICATE-----\nMIIDWTCCAkGgAwIBAgI_SHORTENED_FOR_EXAMPLE_Lgn4jfgtS\n-----END CERTIFICATE-----\n",
   "keyPair": {
       "PublicKey": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BA_SHORTENED_FOR_EXAMPLE_ImwIDAQAB\n-----END PUBLIC KEY-----\n",
       "PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\nMIIEowIBAAKCAQE_SHORTENED_FOR_EXAMPLE_T9RoDiukY\n-----END RSA PRIVATE KEY-----\n"
   }
   }
   ```

1. 이 명령을 입력하여 인증서 디렉터리와 해당 파일에 대한 권한을 설정합니다.

   ```
   chmod 700 ~/certs/pubsub
   chmod 644 ~/certs/pubsub/*
   chmod 600 ~/certs/pubsub/private.pem.key
   ```

1. 이 명령을 실행하여 인증서 디렉터리 및 파일에 대한 권한을 검토합니다.

   ```
   ls -l ~/certs/pubsub
   ```

   명령의 출력은 파일 날짜와 시간이 다르다는 점을 제외하고 여기에 표시되는 것과 같아야 합니다.

   ```
   -rw-r--r-- 1 pi pi 1220 Oct 28 13:02 device.pem.crt
   -rw------- 1 pi pi 1675 Oct 28 13:02 private.pem.key
   -rw-r--r-- 1 pi pi  451 Oct 28 13:02 public.pem.key
   ```

1. 이 명령을 입력하여 로그 파일의 디렉터리를 생성합니다.

   ```
   mkdir ~/.aws-iot-device-client
   mkdir ~/.aws-iot-device-client/log
   chmod 745 ~/.aws-iot-device-client/log
   echo " " > ~/.aws-iot-device-client/log/aws-iot-device-client.log
   echo " " > ~/.aws-iot-device-client/log/pubsub_rx_msgs.log
   chmod 600 ~/.aws-iot-device-client/log/*
   ```

## MQTT 통신을 시연하기 위해 디바이스 프로비저닝
<a name="iot-dc-testconn-provision-aws"></a>

이 섹션에서는에서 Raspberry Pi를 프로비저닝하는 AWS IoT 리소스를 생성합니다 AWS IoT.

**AWS IoT에서 디바이스를 프로비저닝하려면**

1. 로컬 호스트 컴퓨터의 터미널 창에서 이 명령을 입력하여 AWS 계정의 디바이스 데이터 엔드포인트 주소를 가져옵니다.

   ```
   aws iot describe-endpoint --endpoint-type IoT:Data-ATS
   ```

   엔드포인트 값은 이전 튜토리얼에서 이 명령을 실행한 이후로 변경되지 않았습니다. 여기에서 명령을 다시 실행하면 데이터 엔드포인트 값을 쉽게 찾아 이 튜토리얼에서 사용하는 구성 파일에 붙여 넣을 수 있습니다.

   이전 단계의 명령에서 다음과 같은 응답이 반환됩니다. 나중에 사용하기 위해 `endpointAddress` 값을 적어 둡니다.

   ```
   {
   "endpointAddress": "a3qjEXAMPLEffp-ats.iot.us-west-2.amazonaws.com"
   }
   ```

1. Raspberry Pi에 대한 새 AWS IoT 사물 리소스를 생성하려면이 명령을 입력합니다.

   ```
   aws iot create-thing --thing-name "PubSubTestThing"
   ```

    AWS IoT 사물 리소스는 클라우드에서 디바이스를 *가상*으로 표현하기 때문에에서 여러 용도로 AWS IoT 사용할 여러 사물 리소스를 생성할 수 있습니다. 모두 동일한 물리적 IoT 디바이스에서 사용하여 디바이스의 다양한 속성을 나타낼 수 있습니다.

   이 튜토리얼에서는 Raspberry Pi를 표현하기 위해 한 번에 하나의 사물 리소스만 사용합니다. 이렇게 하면이 자습서에서는 다양한 데모를 나타내므로 데모용 AWS IoT 리소스를 생성한 후 돌아가서 각각에 대해 특별히 생성한 리소스를 사용하여 데모를 반복할 수 있습니다.

    AWS IoT 사물 리소스가 생성된 경우 명령은 이와 같은 응답을 반환합니다.

   ```
   {
   "thingName": "PubSubTestThing",
   "thingArn": "arn:aws:iot:us-west-2:57EXAMPLE833:thing/PubSubTestThing",
   "thingId": "8ea78707-32c3-4f8a-9232-14bEXAMPLEfd"
   }
   ```

1. 터미널 창에서

   1. `nano` 등의 텍스트 편집기를 엽니다.

   1. 이 JSON 문서를 복사하여 열려 있는 텍스트 편집기에 붙여 넣습니다.  
****  

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [
              {
                  "Effect": "Allow",
                  "Action": [
                      "iot:Connect"
                  ],
                  "Resource": [
                      "arn:aws:iot:us-west-2:123456789012:client/PubSubTestThing"
                  ]
              },
              {
                  "Effect": "Allow",
                  "Action": [
                      "iot:Publish"
                  ],
                  "Resource": [
                      "arn:aws:iot:us-west-2:123456789012:topic/test/dc/pubtopic"
                  ]
              },
              {
                  "Effect": "Allow",
                  "Action": [
                      "iot:Subscribe"
                  ],
                  "Resource": [
                      "arn:aws:iot:us-west-2:123456789012:topicfilter/test/dc/subtopic"
                  ]
              },
              {
                  "Effect": "Allow",
                  "Action": [
                      "iot:Receive"
                  ],
                  "Resource": [
                      "arn:aws:iot:us-west-2:123456789012:topic/test/dc/subtopic"
                  ]
              }
          ]
      }
      ```

   1. 편집기의 정책 문서의 각 `Resource` 섹션에서 *us-west-2:57EXAMPLE833*을 , 콜론 문자(:) 및 12자리 AWS 계정 숫자 AWS 리전로 바꿉니다.

   1. 텍스트 편집기에서 파일을 **\$1/policies/pubsub\$1test\$1thing\$1policy.json**으로 저장합니다.

1. 이전 단계의 정책 문서를 사용하여 AWS IoT 정책을 생성하려면이 명령을 실행합니다.

   ```
   aws iot create-policy \
   --policy-name "PubSubTestThingPolicy" \
   --policy-document "file://~/policies/pubsub_test_thing_policy.json"
   ```

   정책이 생성되면 명령에서 다음과 같은 응답을 반환합니다.

   ```
   {
                                       "policyName": "PubSubTestThingPolicy",
                                       "policyArn": "arn:aws:iot:us-west-2:57EXAMPLE833:policy/PubSubTestThingPolicy",
                                       "policyDocument": "{\n\"Version\": \"2012-10-17\",		 	 	 \n\"Statement\": [\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Connect\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:client/PubSubTestThing\"\n]\n},\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Publish\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/pubtopic\"\n]\n},\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Subscribe\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/subtopic\"\n]\n},\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Receive\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/*\"\n]\n}\n]\n}\n",
                                       "policyVersionId": "1"
                                       }
   ```

1. 이 명령을 실행하여 디바이스 인증서에 정책을 연결합니다. `certificateArn`을 이 섹션에서 이전에 저장한 `certificateArn` 값으로 바꿉니다.

   ```
   aws iot attach-policy \
   --policy-name "PubSubTestThingPolicy" \
   --target "certificateArn"
   ```

   성공한 경우 이 명령은 아무 것도 반환하지 않습니다.

1. 이 명령을 실행하여 AWS IoT 사물 리소스에 디바이스 인증서를 연결합니다. `certificateArn`을 이 섹션에서 이전에 저장한 `certificateArn` 값으로 바꿉니다.

   ```
   aws iot attach-thing-principal \
   --thing-name "PubSubTestThing" \
   --principal "certificateArn"
   ```

   성공한 경우 이 명령은 아무 것도 반환하지 않습니다.

에서 디바이스를 성공적으로 프로비저닝하면 로 계속 진행할 준비가 된 AWS IoT것입니다[MQTT 통신을 보여주도록 AWS IoT Device Client 구성 파일 및 MQTT 테스트 클라이언트 구성](#iot-dc-testconn-provision-dc-config).

## MQTT 통신을 보여주도록 AWS IoT Device Client 구성 파일 및 MQTT 테스트 클라이언트 구성
<a name="iot-dc-testconn-provision-dc-config"></a>

이 절차에서는 AWS IoT Device Client를 테스트하는 구성 파일을 생성합니다.

**AWS IoT Device Client를 테스트하기 위한 구성 파일을 생성하려면**

1. Raspberry Pi에 연결된 로컬 호스트 컴퓨터의 터미널 창에서

   1. `nano` 등의 텍스트 편집기를 엽니다.

   1. 이 JSON 문서를 복사하여 열려 있는 텍스트 편집기에 붙여 넣습니다.

      ```
      {
        "endpoint": "a3qEXAMPLEaffp-ats.iot.us-west-2.amazonaws.com",
        "cert": "~/certs/pubsub/device.pem.crt",
        "key": "~/certs/pubsub/private.pem.key",
        "root-ca": "~/certs/AmazonRootCA1.pem",
        "thing-name": "PubSubTestThing",
        "logging": {
          "enable-sdk-logging": true,
          "level": "DEBUG",
          "type": "STDOUT",
          "file": ""
        },
        "jobs": {
          "enabled": false,
          "handler-directory": ""
        },
        "tunneling": {
          "enabled": false
        },
        "device-defender": {
          "enabled": false,
          "interval": 300
        },
        "fleet-provisioning": {
          "enabled": false,
          "template-name": "",
          "template-parameters": "",
          "csr-file": "",
          "device-key": ""
        },
        "samples": {
          "pub-sub": {
            "enabled": true,
            "publish-topic": "test/dc/pubtopic",
            "publish-file": "",
            "subscribe-topic": "test/dc/subtopic",
            "subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log"
          }
        },
        "config-shadow": {
          "enabled": false
        },
        "sample-shadow": {
          "enabled": false,
          "shadow-name": "",
          "shadow-input-file": "",
          "shadow-output-file": ""
        }
      }
      ```

   1. *엔드포인트* 값을에서 찾 AWS 계정 은의 디바이스 데이터 엔드포인트로 바꿉니다[에서 디바이스 프로비저닝 AWS IoT Core](iot-dc-install-provision.md#iot-dc-install-dc-provision).

   1. 텍스트 편집기에서 파일을 **\$1/dc-configs/dc-pubsub-config.json**으로 저장합니다.

   1. 이 명령을 실행하여 새로운 구성 파일에 대한 권한을 설정합니다.

      ```
      chmod 644 ~/dc-configs/dc-pubsub-config.json
      ```

1. 모든 MQTT 메시지를 구독하도록 **MQTT 테스트 클라이언트(MQTT test client)**를 준비하려면

   1. 로컬 호스트 컴퓨터의 [AWS IoT 콘솔](https://console.aws.amazon.com//iot/home#/test)에서 **MQTT 테스트 클라이언트(MQTT test client)**를 선택합니다.

   1. **주제 구독(Subscribe to a topic)** 탭의 **주제 필터(Topic filter)**에 **\$1**(파운드 기호 1개)를 입력하고 **구독(Subscribe)**을 선택합니다.

   1. **구독(Subscriptions)** 레이블 아래에 **\$1**(파운드 기호 1개)가 표시되는지 확인합니다.

   이 자습서를 진행하면서 **MQTT 테스트 클라이언트(MQTT test client)**가 열려 있는 창을 그대로 둡니다.

파일을 저장하고 **MQTT 테스트 클라이언트(MQTT test client)**를 구성한 후 [AWS IoT Device Client를 사용하여 메시지 게시 시연](iot-dc-testconn-publish.md)으로 진행할 준비가 된 것입니다.

# AWS IoT Device Client를 사용하여 메시지 게시 시연
<a name="iot-dc-testconn-publish"></a>

이 섹션의 절차는 AWS IoT Device Client가 기본 및 사용자 지정 MQTT 메시지를 보내는 방법을 보여줍니다.

이러한 연습을 위해 이전 단계에서 생성한 정책의 이러한 정책 설명은 Raspberry Pi에 다음 작업을 수행할 수 있는 권한을 부여합니다.
+ 

**`iot:Connect`**  
 AWS IoT Device Client를 실행하는 Raspberry Pi`PubSubTestThing`인 라는 클라이언트에 연결할 권한을 부여합니다.

  ```
      {
        "Effect": "Allow",
        "Action": [
          "iot:Connect"
        ],
        "Resource": [
          "arn:aws:iot:us-west-2:57EXAMPLE833:client/PubSubTestThing"
        ]
      }
  ```
+ 

**`iot:Publish`**  
Raspberry Pi에 `test/dc/pubtopic`의 MQTT 주제가 있는 메시지를 게시할 수 있는 권한을 부여합니다.

  ```
      {
        "Effect": "Allow",
        "Action": [
          "iot:Publish"
        ],
        "Resource": [
          "arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/pubtopic"
        ]
      }
  ```

  `iot:Publish` 작업은 리소스 배열에 나열된 MQTT 주제에 게시할 수 있는 권한을 부여합니다. 이러한 메시지의 *내용*은 정책 설명에 의해 제어되지 않습니다.

## AWS IoT Device Client를 사용하여 기본 메시지 게시
<a name="iot-dc-testconn-publish-default"></a>

이 절차는 AWS IoT Device Client를 실행하여 MQTT **테스트 클라이언트가 수신하고 표시하는 단일 기본 MQTT** 메시지를 게시합니다.

**AWS IoT Device Client에서 기본 MQTT 메시지를 보내려면**

1. 이 절차를 수행하는 동안 Raspberry Pi에 연결된 로컬 호스트 컴퓨터의 터미널 창과 **MQTT 테스트 클라이언트(MQTT test client)**가 있는 창이 모두 표시되는지 확인합니다.

1. 터미널 창에서 다음 명령을 입력하여에서 생성된 구성 파일을 사용하여 AWS IoT Device Client를 실행합니다[구성 파일 생성](iot-dc-install-configure.md#iot-dc-install-dc-configure-step1).

   ```
   cd ~/aws-iot-device-client/build
   ./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-config.json
   ```

   터미널 창에서 AWS IoT Device Client는 정보 메시지와 실행 시 발생하는 오류를 표시합니다.

   터미널 창에 오류가 표시되지 않으면 **MQTT 테스트 클라이언트(MQTT test client)**를 검토합니다.

1. **MQTT 테스트 클라이언트**의 **구독** 창에서 `test/dc/pubtopic` 메시지 주제로 *Hello World\$1* 메시지가 전송되었음을 확인할 수 있습니다.

1.  AWS IoT Device Client에 오류가 표시되지 않고 *Hello World\$1*가 **MQTT 테스트 클라이언트**의 `test/dc/pubtopic` 메시지로 전송된 것을 볼 수 있는 경우 성공적인 연결을 입증한 것입니다.

1. 터미널 창에서 **^C** (Ctrl-C)를 입력하여 AWS IoT Device Client를 중지합니다.

 AWS IoT Device Client가 기본 MQTT 메시지를 게시했음을 입증한 후 로 계속 진행할 수 있습니다[AWS IoT Device Client를 사용하여 사용자 지정 메시지 게시](#iot-dc-testconn-publish-custom).

## AWS IoT Device Client를 사용하여 사용자 지정 메시지 게시
<a name="iot-dc-testconn-publish-custom"></a>

이 섹션의 절차에서는 사용자 정의 MQTT 메시지를 생성한 다음 AWS IoT Device Client를 실행하여 **MQTT 테스트 클라이언트(MQTT test client)**가 수신하고 표시할 수 있도록 사용자 정의 MQTT 메시지를 한 번 게시합니다.

### AWS IoT Device Client에 대한 사용자 지정 MQTT 메시지 생성
<a name="iot-dc-testconn-publish-custom-create"></a>

Raspberry Pi에 연결된 로컬 호스트 컴퓨터의 터미널 창에서 다음 단계를 수행합니다.

**AWS IoT Device Client가 게시할 사용자 지정 메시지를 생성하려면**

1. 터미널 창에서 `nano` 등의 텍스트 편집기를 엽니다.

1. 텍스트 편집기에 다음 JSON 문서를 복사하여 붙여 넣습니다. 이는 AWS IoT Device Client가 게시하는 MQTT 메시지 페이로드입니다.

   ```
   {
     "temperature": 28,
     "humidity": 80,
     "barometer": 1013,
     "wind": {
       "velocity": 22,
       "bearing": 255
     }
   }
   ```

1. 텍스트 편집기의 내용을 **\$1/messages/sample-ws-message.json**으로 저장합니다.

1. 다음 명령을 입력하여 방금 생성한 메시지 파일의 권한을 설정합니다.

   ```
   chmod 600 ~/messages/*
   ```

**AWS IoT Device Client가 사용자 지정 메시지를 전송하는 데 사용할 구성 파일을 생성하려면**

1. 터미널 창의와 같은 텍스트 편집기에서 기존 AWS IoT Device Client 구성 파일을 `nano`엽니다**\$1/dc-configs/dc-pubsub-config.json**.

1. 다음과 같이 `samples` 객체를 편집합니다. 이 파일의 다른 부분은 변경할 필요가 없습니다.

   ```
     "samples": {
       "pub-sub": {
         "enabled": true,
         "publish-topic": "test/dc/pubtopic",
         "publish-file": "~/messages/sample-ws-message.json",
         "subscribe-topic": "test/dc/subtopic",
         "subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log"
   ```

1. 텍스트 편집기의 내용을 **\$1/dc-configs/dc-pubsub-custom-config.json**으로 저장합니다.

1. 이 명령을 실행하여 새로운 구성 파일에 대한 권한을 설정합니다.

   ```
   chmod 644 ~/dc-configs/dc-pubsub-custom-config.json
   ```

### AWS IoT Device Client를 사용하여 사용자 지정 MQTT 메시지 게시
<a name="iot-dc-testconn-publish-custom-publish"></a>

이 변경 사항은 MQTT 메시지 페이로드의 *내용*에만 영향을 주므로 현재 정책이 계속 작동합니다. 그러나 *MQTT 주제*(`~/dc-configs/dc-pubsub-custom-config.json`의 `publish-topic` 값으로 정의됨)가 변경된 경우 Raspberry Pi가 새 MQTT 주제에 게시할 수 있도록 `iot::Publish` 정책 설명도 수정해야 합니다.

**AWS IoT Device Client에서 MQTT 메시지를 보내려면**

1. 이 절차를 수행하는 동안 터미널 창과 **MQTT 테스트 클라이언트(MQTT test client)**가 있는 창이 모두 표시되는지 확인합니다. 또한 **MQTT 테스트 클라이언트(MQTT test client)**가 여전히 **\$1** 주제 필터를 구독하고 있는지 확인합니다. 그렇지 않은 경우 **\$1** 주제 필터를 다시 구독합니다.

1. 터미널 창에서 이 명령을 입력하여 [구성 파일 생성](iot-dc-install-configure.md#iot-dc-install-dc-configure-step1)에서 생성한 config 파일을 사용하여 AWS IoT Device Client를 실행합니다.

   ```
   cd ~/aws-iot-device-client/build
   ./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-custom-config.json
   ```

   터미널 창에서 AWS IoT Device Client는 정보 메시지와 실행 시 발생하는 오류를 표시합니다.

   터미널 창에 오류가 표시되지 않으면 MQTT 테스트 클라이언트(MQTT test client)를 검토합니다.

1. **MQTT 테스트 클라이언트**의 **구독** 창에서 `test/dc/pubtopic` 메시지 주제로 사용자 정의 메시지 페이로드가 전송되었음을 확인할 수 있습니다.

1.  AWS IoT Device Client에 오류가 표시되지 않고 **MQTT 테스트 클라이언트**의 메시지에 게시한 사용자 지정 `test/dc/pubtopic` 메시지 페이로드가 표시되면 사용자 지정 메시지를 성공적으로 게시한 것입니다.

1. 터미널 창에서 **^C** (Ctrl-C)를 입력하여 AWS IoT Device Client를 중지합니다.

 AWS IoT Device Client가 사용자 지정 메시지 페이로드를 게시했음을 입증한 후 로 계속 진행할 수 있습니다[AWS IoT Device Client를 사용하여 메시지 구독 시연](iot-dc-testconn-subscribe.md).

# AWS IoT Device Client를 사용하여 메시지 구독 시연
<a name="iot-dc-testconn-subscribe"></a>

이 섹션에서는 두 가지 유형의 메시지 구독을 보여줍니다.
+ 단일 주제 구독
+ 와일드카드 주제 구독

이러한 연습을 위해 생성한 정책의 이러한 정책 설명은 Raspberry Pi에 다음 작업을 수행할 수 있는 권한을 부여합니다.
+ 

**`iot:Receive`**  
 AWS IoT Device Client에 `Resource` 객체에 이름이 지정된 주제와 일치하는 MQTT 주제를 수신할 수 있는 권한을 부여합니다.

  ```
      {
        "Effect": "Allow",
        "Action": [
          "iot:Receive"
        ],
        "Resource": [
          "arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/subtopic"
        ]
      }
  ```
+ 

**`iot:Subscribe`**  
 AWS IoT Device Client에 `Resource` 객체에 이름이 지정된 것과 일치하는 MQTT 주제 필터를 구독할 수 있는 권한을 부여합니다.

  ```
      {
        "Effect": "Allow",
        "Action": [
          "iot:Subscribe"
        ],
        "Resource": [
          "arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/subtopic"
        ]
      }
  ```

## 단일 MQTT 메시지 주제 구독
<a name="iot-dc-testconn-subscribe-simple-topic"></a>

이 절차에서는 AWS IoT Device Client가 MQTT 메시지를 구독하고 로깅하는 방법을 보여줍니다.

Raspberry Pi에 연결된 로컬 호스트 컴퓨터의 터미널 창에서 **\$1/dc-configs/dc-pubsub-custom-config.json**의 내용을 나열하거나 텍스트 편집기에서 파일을 열어 내용을 검토합니다. 다음과 같은 `samples` 객체를 찾습니다.

```
  "samples": {
    "pub-sub": {
      "enabled": true,
      "publish-topic": "test/dc/pubtopic",
      "publish-file": "~/messages/sample-ws-message.json",
      "subscribe-topic": "test/dc/subtopic",
      "subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log"
```

`subscribe-topic` 값은 AWS IoT Device Client가 실행 시 구독할 MQTT 주제입니다. AWS IoT Device Client는이 구독에서 수신한 메시지 페이로드를 `subscribe-file` 값에 라는 파일에 씁니다.

**AWS IoT Device Client에서 MQTT 메시지 주제를 구독하려면**

1. 이 절차를 수행하는 동안 터미널 창과 MQTT 테스트 클라이언트(MQTT test client)가 있는 창이 모두 표시되는지 확인합니다. 또한 **MQTT 테스트 클라이언트(MQTT test client)**가 여전히 **\$1** 주제 필터를 구독하고 있는지 확인합니다. 그렇지 않은 경우 **\$1** 주제 필터를 다시 구독합니다.

1. 터미널 창에서 다음 명령을 입력하여에서 생성된 구성 파일을 사용하여 AWS IoT Device Client를 실행합니다[구성 파일 생성](iot-dc-install-configure.md#iot-dc-install-dc-configure-step1).

   ```
   cd ~/aws-iot-device-client/build
   ./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-custom-config.json
   ```

   터미널 창에서 AWS IoT Device Client는 정보 메시지와 실행 시 발생하는 오류를 표시합니다.

   터미널 창에 오류가 표시되지 않으면 AWS IoT 콘솔에서 계속합니다.

1.  AWS IoT 콘솔의 **MQTT 테스트 클라이언트**에서 **주제에 게시** 탭을 선택합니다.

1. **주제 이름(Topic name)**에 **test/dc/subtopic**을 입력합니다.

1. **메시지 페이로드(Message payload)**에서 메시지 내용을 검토합니다.

1. **게시(Publish)**를 선택하여 MQTT 메시지를 게시합니다.

1. 터미널 창에서 다음과 같은 AWS IoT Device Client에서 *받은 메시지 * 항목을 확인합니다.

   ```
   2021-11-10T16:02:20.890Z [DEBUG] {samples/PubSubFeature.cpp}: Message received on subscribe topic, size: 45 bytes
   ```

1. *메시지가 수신*되었음을 보여주는 메시지 수신 항목이 표시되면 **^C** (Ctrl-C)를 입력하여 AWS IoT Device Client를 중지합니다.

1. 이 명령을 입력하여 메시지 로그 파일의 끝을 보고 **MQTT 테스트 클라이언트(MQTT test client)**에서 게시한 메시지를 확인합니다.

   ```
   tail ~/.aws-iot-device-client/log/pubsub_rx_msgs.log
   ```

로그 파일에서 메시지를 보고 AWS IoT Device Client가 MQTT 테스트 클라이언트에서 게시한 메시지를 수신했음을 보여줍니다.

## 와일드카드 문자를 사용하여 여러 MQTT 메시지 주제 구독
<a name="iot-dc-testconn-subscribe-wild-topic"></a>

이 절차는 AWS IoT Device Client가 와일드카드 문자를 사용하여 MQTT 메시지를 구독하고 로깅하는 방법을 보여줍니다. 이를 위해 다음을 수행합니다.

1.  AWS IoT Device Client가 MQTT 주제를 구독하는 데 사용하는 주제 필터를 업데이트합니다.

1. 새 구독을 허용하도록 디바이스에서 사용하는 정책을 업데이트합니다.

1.  AWS IoT Device Client를 실행하고 MQTT 테스트 콘솔에서 메시지를 게시합니다.

**와일드카드 MQTT 주제 필터를 사용하여 여러 MQTT 메시지 주제를 구독하는 구성 파일을 생성하려면**

1. Raspberry Pi에 연결된 로컬 호스트 컴퓨터의 터미널 창에서 편집을 위해 **\$1/dc-configs/dc-pubsub-custom-config.json**을 열고 `samples` 객체를 찾습니다.

1. 텍스트 편집기에서 `samples` 객체를 찾고 `subscribe-topic` 값을 다음과 같이 업데이트합니다.

   ```
     "samples": {
       "pub-sub": {
         "enabled": true,
         "publish-topic": "test/dc/pubtopic",
         "publish-file": "~/messages/sample-ws-message.json",
         "subscribe-topic": "test/dc/#",
         "subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log"
   ```

   새 `subscribe-topic` 값은 끝에 MQTT 와일드카드 문자가 있는 [MQTT 주제 필터](topics.md#topicfilters)입니다. 이는 `test/dc/`로 시작하는 모든 MQTT 주제에 대한 구독을 설명합니다. AWS IoT Device Client는이 구독에서 수신한 메시지 페이로드를의 파일에 씁니다`subscribe-file`.

1. 수정된 구성 파일을 **\$1/dc-configs/dc-pubsub-wild-config.json**으로 저장하고 편집기를 종료합니다.

**여러 MQTT 메시지 주제 구독 및 수신을 허용하도록 Raspberry Pi에서 사용하는 정책을 수정하려면**

1. Raspberry Pi에 연결된 로컬 호스트 컴퓨터의 터미널 창에서 즐겨 사용하는 텍스트 편집기에서 편집을 위해 **\$1/policies/pubsub\$1test\$1thing\$1policy.json**을 연 다음 파일에서 `iot::Subscribe` 및 `iot::Receive` 정책 설명을 찾습니다.

1. `iot::Subscribe` 정책 설명에서 Resource 개체의 문자열을 업데이트하여 `subtopic`을 `*`로 바꾸면 다음과 같이 됩니다.

   ```
       {
         "Effect": "Allow",
         "Action": [
           "iot:Subscribe"
         ],
         "Resource": [
           "arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/*"
         ]
       }
   ```
**참고**  
[MQTT 주제 필터 와일드 카드 문자](topics.md#topicfilters)는 `+`(더하기 기호)와 `#`(파운드 기호)입니다. 끝에 `#`이 있는 구독 요청은 `#` 문자 앞에 오는 문자열(예: 이 경우 `test/dc/`)로 시작하는 모든 주제를 구독합니다.  
그러나 이 구독 권한을 부여하는 정책 설명의 리소스 값은 주제 필터 ARN에서 `#`(파운드 기호) 대신 `*`(별표)를 사용해야 합니다. 이는 정책 프로세서가 MQTT에서 사용하는 것과 다른 와일드카드 문자를 사용하기 때문입니다.  
정책의 주제 및 주제 필터에 와일드카드 문자 사용에 대한 자세한 내용은 [MQTT 및 AWS IoT Core 정책에서 와일드카드 문자 사용](pub-sub-policy.md#pub-sub-policy-cert) 섹션을 참조하세요.

1. `iot::Receive` 정책 설명에서 Resource 개체의 문자열을 업데이트하여 `subtopic`을 `*`로 바꾸면 다음과 같이 됩니다.

   ```
       {
         "Effect": "Allow",
         "Action": [
           "iot:Receive"
         ],
         "Resource": [
           "arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/*"
         ]
       }
   ```

1. 업데이트된 정책 문서를 **\$1/policies/pubsub\$1wild\$1test\$1thing\$1policy.json**으로 저장하고 편집기를 종료합니다.

1. 이 명령을 입력하여 새 리소스 정의를 사용하도록 이 튜토리얼의 정책을 업데이트합니다.

   ```
   aws iot create-policy-version \
   --set-as-default \
   --policy-name "PubSubTestThingPolicy" \
   --policy-document "file://~/policies/pubsub_wild_test_thing_policy.json"
   ```

   명령이 성공하면 다음과 같은 응답이 반환됩니다. `policyVersionId`는 이제 `2`로, 이 정책의 두 번째 버전임을 나타냅니다.

   정책을 성공적으로 업데이트했으면 다음 절차로 진행할 수 있습니다.

   ```
   {
       "policyArn": "arn:aws:iot:us-west-2:57EXAMPLE833:policy/PubSubTestThingPolicy",
       "policyDocument": "{\n  \"Version\": \"2012-10-17\",		 	 	 \n  \"Statement\": [\n    {\n      \"Effect\": \"Allow\",\n      \"Action\": [\n        \"iot:Connect\"\n      ],\n      \"Resource\": [\n        \"arn:aws:iot:us-west-2:57EXAMPLE833:client/PubSubTestThing\"\n      ]\n    },\n    {\n      \"Effect\": \"Allow\",\n      \"Action\": [\n        \"iot:Publish\"\n      ],\n      \"Resource\": [\n        \"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/pubtopic\"\n      ]\n    },\n    {\n      \"Effect\": \"Allow\",\n      \"Action\": [\n        \"iot:Subscribe\"\n      ],\n      \"Resource\": [\n        \"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/*\"\n      ]\n    },\n    {\n      \"Effect\": \"Allow\",\n      \"Action\": [\n        \"iot:Receive\"\n      ],\n      \"Resource\": [\n        \"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/*\"\n      ]\n    }\n  ]\n}\n",
       "policyVersionId": "2",
       "isDefaultVersion": true
   }
   ```

   정책 버전이 너무 많아 새 버전을 저장할 수 없다는 오류가 발생하면 이 명령을 입력하여 정책의 현재 버전을 나열합니다. 이 명령이 반환하는 목록을 검토하여 삭제할 수 있는 정책 버전을 찾습니다.

   ```
   aws iot list-policy-versions --policy-name "PubSubTestThingPolicy"
   ```

   이 명령을 입력하여 더 이상 필요 없는 버전을 삭제합니다. 기본 정책 버전은 삭제할 수 없습니다. 기본 정책 버전은 `isDefaultVersion` 값이 `true`인 버전입니다.

   ```
   aws iot delete-policy-version \
   --policy-name "PubSubTestThingPolicy" \
   --policy-version-id policyId
   ```

   정책 버전을 삭제한 후 이 단계를 다시 시도합니다.

업데이트된 구성 파일 및 정책을 사용하면 AWS IoT Device Client를 사용하여 와일드카드 구독을 시연할 준비가 된 것입니다.

**AWS IoT Device Client가 여러 MQTT 메시지 주제를 구독하고 수신하는 방법을 보여주는 방법**

1. **MQTT 테스트 클라이언트(MQTT test client)**에서 구독을 확인합니다. **MQTT 테스트 클라이언트**가 **\$1** 주제 필터를 구독하는 경우 다음 단계로 진행합니다. 그렇지 않은 경우 **MQTT 테스트 클라이언트**의 **주제 구독** 탭에 있는 **주제 필터**에 **\$1**(파운드 기호)를 입력한 다음 **구독**을 선택하여 이를 구독합니다.

1. Raspberry Pi에 연결된 로컬 호스트 컴퓨터의 터미널 창에서 이 명령을 입력하여 AWS IoT Device Client를 시작합니다.

   ```
   cd ~/aws-iot-device-client/build
   ./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-wild-config.json
   ```

1. 로컬 호스트 컴퓨터의 터미널 창에서 AWS IoT Device Client 출력을 보면서 **MQTT 테스트 클라이언트**로 돌아갑니다. **주제에 게시(Publish to a topic)** 탭의 **주제 이름(Topic name)**에 **test/dc/subtopic**을 입력한 다음 **게시(Publish)**를 선택합니다.

1. 터미널 창에서 다음과 같은 메시지를 찾아 메시지가 수신되었는지 확인합니다.

   ```
   2021-11-10T16:34:20.101Z [DEBUG] {samples/PubSubFeature.cpp}: Message received on subscribe topic, size: 76 bytes
   ```

1. 로컬 호스트 컴퓨터의 터미널 창에서 AWS IoT Device Client 출력을 보면서 **MQTT 테스트 클라이언트**로 돌아갑니다. **주제에 게시(Publish to a topic)** 탭의 **주제 이름(Topic name)**에 **test/dc/subtopic2**을 입력한 다음 **게시(Publish)**를 선택합니다.

1. 터미널 창에서 다음과 같은 메시지를 찾아 메시지가 수신되었는지 확인합니다.

   ```
   2021-11-10T16:34:32.078Z [DEBUG] {samples/PubSubFeature.cpp}: Message received on subscribe topic, size: 77 bytes
   ```

1. 두 메시지가 모두 수신되었음을 확인하는 메시지가 표시되면 **^C** (Ctrl-C)를 입력하여 AWS IoT Device Client를 중지합니다.

1. 이 명령을 입력하여 메시지 로그 파일의 끝을 보고 **MQTT 테스트 클라이언트(MQTT test client)**에서 게시한 메시지를 확인합니다.

   ```
   tail -n 20 ~/.aws-iot-device-client/log/pubsub_rx_msgs.log
   ```
**참고**  
로그 파일에는 메시지 페이로드만 포함됩니다. 수신한 메시지 로그 파일에는 메시지 주제가 기록되지 않습니다.  
수신된 로그에 AWS IoT Device Client가 게시한 메시지가 표시될 수도 있습니다. 이는 와일드카드 주제 필터에 해당 메시지 주제가 포함되어 있으며, 게시된 메시지가 구독자에게 전송되기 전에 메시지 브로커가 구독 요청을 처리할 수도 있기 때문입니다.

로그 파일의 항목은 메시지가 수신되었음을 보여줍니다. 다른 주제 이름을 사용하여 이 절차를 반복할 수 있습니다. 주제 이름이 `test/dc/`로 시작하는 모든 메시지는 수신되고 로그되어야 합니다. 주제 이름이 다른 텍스트로 시작하는 메시지는 무시됩니다.

 AWS IoT Device Client가 MQTT 메시지를 게시하고 구독하는 방법을 보여준 후 로 계속 진행합니다[자습서: AWS IoT Device Client를 사용하여 원격 작업(작업) 시연](iot-dc-runjobs.md).

# 자습서: AWS IoT Device Client를 사용하여 원격 작업(작업) 시연
<a name="iot-dc-runjobs"></a>

이 튜토리얼에서는 IoT 디바이스에 원격 작업을 전송하는 방법을 보여주기 위해 작업을 구성하고 Raspberry Pi에 배포합니다.

**이 자습서를 시작하려면:**
+ [이전 섹션](iot-dc-testconn.md)에서 사용한 대로 로컬 호스트 컴퓨터와 Raspberry Pi를 구성합니다.
+ 이전 섹션의 자습서를 완료하지 않은 경우에 AWS IoT Device Client를 설치한 후 저장한 이미지가 있는 microSD 카드와 함께 Raspberry Pi를 사용하여이 자습서를 시도할 수 있습니다[(선택 사항) microSD 카드 이미지 저장](iot-dc-install-download.md#iot-dc-install-dc-save).
+ 이전에이 데모를 실행한 적이 있는 경우 [2단계: AWS IoT Device Client로 데모를 빌드한 AWS 계정 후 정리](iot-dc-cleanup.md#iot-dc-cleanup-cloud)를 검토하여 이전 실행에서 생성한 모든 AWS IoT 리소스를 삭제하여 중복 리소스 오류를 방지합니다.

이 자습서는 완료하는 데 약 45분이 소요됩니다.

**이 주제를 마치면**
+ IoT 디바이스가를 AWS IoT Core 사용하여에서 관리하는 원격 작업을 실행할 수 있는 다양한 방법을 보여 주었을 것입니다 AWS IoT .

**필수 장비:**
+ [이전 섹션](iot-dc-install-dc.md)에서 테스트한 로컬 개발 및 테스트 환경
+ [이전 섹션](iot-dc-install-dc.md)에서 테스트한 Raspberry Pi
+ [이전 섹션](iot-dc-install-dc.md)에서 테스트한 Raspberry Pi의 microSD 메모리 카드

**Topics**
+ [작업을 실행할 Raspberry Pi 준비](iot-dc-runjobs-prepare.md)
+ [AWS IoT Device Client를 AWS IoT 사용하여에서 작업 생성 및 실행](iot-dc-runjobs-prepare-define.md)

# 작업을 실행할 Raspberry Pi 준비
<a name="iot-dc-runjobs-prepare"></a>

이 섹션의 절차에서는 AWS IoT Device Client를 사용하여 작업을 실행하도록 Raspberry Pi를 준비하는 방법을 설명합니다.

**참고**  
이러한 절차는 디바이스에 따라 다릅니다. 동시에 여러 디바이스로 이 섹션의 절차를 수행하려면 각 디바이스에 고유한 정책과 고유한 디바이스별 인증서 및 사물 이름이 필요합니다. 각 디바이스에 고유한 리소스를 제공하려면 절차에 설명된 대로 디바이스별 요소를 변경하면서 각 디바이스에 대해 이 절차를 한 번 수행합니다.

**Topics**
+ [Raspberry Pi를 프로비저닝하여 직업 시연](#iot-dc-runjobs-prepare-provision)
+ [작업 에이전트를 실행하도록 AWS IoT Device Client 구성](#iot-dc-runjobs-prepare-config)

## Raspberry Pi를 프로비저닝하여 직업 시연
<a name="iot-dc-runjobs-prepare-provision"></a>

이 섹션의 절차는 Raspberry Pi에 대한 AWS IoT 리소스 및 디바이스 인증서를 생성 AWS IoT 하여에서 Raspberry Pi를 프로비저닝합니다.

**Topics**
+ [디바이스 인증서 파일을 생성하고 다운로드하여 AWS IoT 작업 시연](#iot-dc-runjobs-prepare-cert)
+ [AWS IoT 작업을 시연하기 위한 AWS IoT 리소스 생성](#iot-dc-runjobs-prepare-iot)

### 디바이스 인증서 파일을 생성하고 다운로드하여 AWS IoT 작업 시연
<a name="iot-dc-runjobs-prepare-cert"></a>

이 절차는 이 데모에 대한 디바이스 인증서 파일을 생성합니다.

여러 디바이스를 준비하는 경우 각 디바이스에서 이 절차를 수행해야 합니다.

**Raspberry Pi에 대한 디바이스 인증서 파일을 생성하고 다운로드하려면**

Raspberry Pi에 연결된 로컬 호스트 컴퓨터의 터미널 창에서 이 명령을 입력합니다.

1. 다음 명령을 입력하여 디바이스에 대한 디바이스 인증서 파일을 만듭니다.

   ```
   aws iot create-keys-and-certificate \
   --set-as-active \
   --certificate-pem-outfile "~/certs/jobs/device.pem.crt" \
   --public-key-outfile "~/certs/jobs/public.pem.key" \
   --private-key-outfile "~/certs/jobs/private.pem.key"
   ```

   이 명령은 다음과 같은 응답을 반환합니다. 나중에 사용할 수 있도록 `certificateArn` 값을 저장합니다.

   ```
   {
   "certificateArn": "arn:aws:iot:us-west-2:57EXAMPLE833:cert/76e7e4edb3e52f52334be2f387a06145b2aa4c7fcd810f3aea2d92abc227d269",
   "certificateId": "76e7e4edb3e52f5233EXAMPLE7a06145b2aa4c7fcd810f3aea2d92abc227d269",
   "certificatePem": "-----BEGIN CERTIFICATE-----\nMIIDWTCCAkGgAwIBAgI_SHORTENED_FOR_EXAMPLE_Lgn4jfgtS\n-----END CERTIFICATE-----\n",
   "keyPair": {
       "PublicKey": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BA_SHORTENED_FOR_EXAMPLE_ImwIDAQAB\n-----END PUBLIC KEY-----\n",
       "PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\nMIIEowIBAAKCAQE_SHORTENED_FOR_EXAMPLE_T9RoDiukY\n-----END RSA PRIVATE KEY-----\n"
   }
   }
   ```

1. 이 명령을 입력하여 인증서 디렉터리와 해당 파일에 대한 권한을 설정합니다.

   ```
   chmod 700 ~/certs/jobs
   chmod 644 ~/certs/jobs/*
   chmod 600 ~/certs/jobs/private.pem.key
   ```

1. 이 명령을 실행하여 인증서 디렉터리 및 파일에 대한 권한을 검토합니다.

   ```
   ls -l ~/certs/jobs
   ```

   명령의 출력은 파일 날짜와 시간이 다르다는 점을 제외하고 여기에 표시되는 것과 같아야 합니다.

   ```
   -rw-r--r-- 1 pi pi 1220 Oct 28 13:02 device.pem.crt
   -rw------- 1 pi pi 1675 Oct 28 13:02 private.pem.key
   -rw-r--r-- 1 pi pi  451 Oct 28 13:02 public.pem.key
   ```

디바이스 인증서 파일을 Raspberry Pi에 다운로드했으면 [Raspberry Pi를 프로비저닝하여 직업 시연](#iot-dc-runjobs-prepare-provision)으로 진행할 준비가 된 것입니다.

### AWS IoT 작업을 시연하기 위한 AWS IoT 리소스 생성
<a name="iot-dc-runjobs-prepare-iot"></a>

이 디바이스에 대한 AWS IoT 리소스를 생성합니다.

여러 디바이스를 준비하는 경우 각 디바이스에 대해 이 절차를 수행해야 합니다.



**AWS IoT에서 디바이스를 프로비저닝하려면**

Raspberry Pi에 연결된 로컬 호스트 컴퓨터의 터미널 창에서

1. 다음 명령을 입력하여 AWS 계정에 대한 디바이스 데이터 엔드포인트의 주소를 가져옵니다.

   ```
   aws iot describe-endpoint --endpoint-type IoT:Data-ATS
   ```

   엔드포인트 값은 이 명령을 마지막으로 실행한 이후로 변경되지 않았습니다. 여기에서 명령을 다시 실행하면 데이터 엔드포인트 값을 쉽게 찾아 이 자습서에서 사용하는 구성 파일에 붙여 넣을 수 있습니다.

   **describe-endpoint** 명령은 다음과 같은 응답을 반환합니다. 나중에 사용하기 위해 `endpointAddress` 값을 적어 둡니다.

   ```
   {
   "endpointAddress": "a3qjEXAMPLEffp-ats.iot.us-west-2.amazonaws.com"
   }
   ```

1. *uniqueThingName*을 디바이스의 고유 이름으로 바꿉니다. 여러 디바이스에서 이 튜토리얼을 수행하려면 각 디바이스에 고유한 이름을 지정합니다. 예: **TestDevice01**, **TestDevice02** 등.

   Raspberry Pi에 대한 새 AWS IoT 사물 리소스를 생성하려면이 명령을 입력합니다.

   ```
   aws iot create-thing --thing-name "uniqueThingName"
   ```

    AWS IoT 사물 리소스는 클라우드에서 디바이스를 *가상*으로 표현하기 때문에에서 여러 용도로 AWS IoT 사용할 여러 사물 리소스를 생성할 수 있습니다. 모두 동일한 물리적 IoT 디바이스에서 사용하여 디바이스의 다양한 속성을 나타낼 수 있습니다.
**참고**  
여러 장치에 대한 정책을 보호하려는 경우 고정 사물 이름인 `uniqueThingName` 대신 `${iot:Thing.ThingName}`을 사용할 수 있습니다.

   이 튜토리얼에서는 디바이스당 한 번에 하나의 사물 리소스만 사용합니다. 이렇게 하면이 자습서에서는 다양한 데모를 나타내므로 데모용 AWS IoT 리소스를 생성한 후 돌아가서 각각에 대해 특별히 생성한 리소스를 사용하여 데모를 반복할 수 있습니다.

    AWS IoT 사물 리소스가 생성된 경우 명령은 이와 같은 응답을 반환합니다. 나중에 이 디바이스에서 실행할 작업을 생성할 때 사용할 `thingArn` 값을 기록합니다.

   ```
   {
   "thingName": "uniqueThingName",
   "thingArn": "arn:aws:iot:us-west-2:57EXAMPLE833:thing/uniqueThingName",
   "thingId": "8ea78707-32c3-4f8a-9232-14bEXAMPLEfd"
   }
   ```

1. 터미널 창에서

   1. `nano` 등의 텍스트 편집기를 엽니다.

   1. 이 JSON 문서를 복사하여 열려 있는 텍스트 편집기에 붙여 넣습니다.  
****  

      ```
      {
          "Version":"2012-10-17",		 	 	 
          "Statement": [
              {
                  "Effect": "Allow",
                  "Action": [
                      "iot:Connect"
                  ],
                  "Resource": [
                      "arn:aws:iot:us-west-2:123456789012:client/uniqueThingName"
                  ]
              },
              {
                  "Effect": "Allow",
                  "Action": [
                      "iot:Publish"
                  ],
                  "Resource": [
                      "arn:aws:iot:us-west-2:123456789012:topic/test/dc/pubtopic",
                      "arn:aws:iot:us-west-2:123456789012:topic/$aws/events/job/*",
                      "arn:aws:iot:us-west-2:123456789012:topic/$aws/events/jobExecution/*",
                      "arn:aws:iot:us-west-2:123456789012:topic/$aws/things/uniqueThingName/jobs/*"
                  ]
              },
              {
                  "Effect": "Allow",
                  "Action": [
                      "iot:Subscribe"
                  ],
                  "Resource": [
                      "arn:aws:iot:us-west-2:123456789012:topicfilter/test/dc/subtopic",
                      "arn:aws:iot:us-west-2:123456789012:topic/$aws/events/jobExecution/*",
                      "arn:aws:iot:us-west-2:123456789012:topicfilter/$aws/things/uniqueThingName/jobs/*"
                  ]
              },
              {
                  "Effect": "Allow",
                  "Action": [
                      "iot:Receive"
                  ],
                  "Resource": [
                      "arn:aws:iot:us-west-2:123456789012:topic/test/dc/subtopic",
                      "arn:aws:iot:us-west-2:123456789012:topic/$aws/things/uniqueThingName/jobs/*"
                  ]
              },
              {
                  "Effect": "Allow",
                  "Action": [
                      "iot:DescribeJobExecution",
                      "iot:GetPendingJobExecutions",
                      "iot:StartNextPendingJobExecution",
                      "iot:UpdateJobExecution"
                  ],
                  "Resource": [
                      "arn:aws:iot:us-west-2:123456789012:topic/$aws/things/uniqueThingName"
                  ]
              }
          ]
      }
      ```

   1. 편집기에서 모든 정책 설명 `Resource` 섹션의 *us-west-2:57EXAMPLE833*을 AWS 리전, 콜론 문자(:) 및 12자리 AWS 계정 번호로 바꿉니다.

   1. 편집기의 모든 정책 설명에서 *uniqueThingName*을 이 사물 리소스에 지정한 사물 이름으로 바꿉니다.

   1. 텍스트 편집기에서 파일을 **\$1/policies/jobs\$1test\$1thing\$1policy.json**으로 저장합니다.

      여러 디바이스에 대해 이 절차를 실행하는 경우 파일을 각 디바이스에 이 파일 이름으로 저장합니다.

1. *uniqueThingName*을 디바이스의 사물 이름으로 바꾼 다음이 명령을 실행하여 해당 디바이스에 맞는 AWS IoT 정책을 생성합니다.

   ```
   aws iot create-policy \
   --policy-name "JobTestPolicyForuniqueThingName" \
   --policy-document "file://~/policies/jobs_test_thing_policy.json"
   ```

   정책이 생성되면 명령에서 다음과 같은 응답을 반환합니다.  
****  

   ```
   {
       "policyName": "JobTestPolicyForuniqueThingName",
       "policyArn": "arn:aws:iot:us-west-2:57EXAMPLE833:policy/JobTestPolicyForuniqueThingName",
       "policyDocument": "{\n\"Version\": \"2012-10-17\",\n\"Statement\": [\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Connect\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:client/PubSubTestThing\"\n]\n},\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Publish\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/pubtopic\"\n]\n},\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Subscribe\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/subtopic\"\n]\n},\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Receive\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/*\"\n]\n}\n]\n}\n",
       "policyVersionId": "1"
   }
   ```

1. *uniqueThingName*을 디바이스의 사물 이름으로 바꾸고 `certificateArn`을 이 디바이스에 대해 이 섹션 앞부분에서 저장한 `certificateArn` 값으로 바꾼 다음 이 명령을 실행하여 정책을 디바이스 인증서에 연결합니다.

   ```
   aws iot attach-policy \
   --policy-name "JobTestPolicyForuniqueThingName" \
   --target "certificateArn"
   ```

   성공한 경우 이 명령은 아무 것도 반환하지 않습니다.

1.  *uniqueThingName*을 디바이스의 사물 이름으로 바꾸고이 섹션`certificateArn`의 앞부분에서 저장한 `certificateArn` 값으로 바꾼 다음이 명령을 실행하여 디바이스 인증서를 AWS IoT 사물 리소스에 연결합니다.

   ```
   aws iot attach-thing-principal \
   --thing-name "uniqueThingName" \
   --principal "certificateArn"
   ```

   성공한 경우 이 명령은 아무 것도 반환하지 않습니다.

Raspberry Pi를 성공적으로 프로비저닝한 후에는 테스트에서 다른 Raspberry Pi에 대해 이 섹션을 반복할 준비가 된 것입니다. 모든 디바이스가 프로비저닝된 경우 [작업 에이전트를 실행하도록 AWS IoT Device Client 구성](#iot-dc-runjobs-prepare-config)으로 진행합니다.

## 작업 에이전트를 실행하도록 AWS IoT Device Client 구성
<a name="iot-dc-runjobs-prepare-config"></a>

이 절차에서는 AWS IoT Device Client가 작업 에이전트를 실행할 수 있는 구성 파일을 생성합니다.

참고: 여러 디바이스를 준비하는 경우 각 디바이스에서 이 절차를 수행해야 합니다.

**AWS IoT Device Client를 테스트하는 구성 파일을 생성하려면:**

1. Raspberry Pi에 연결된 로컬 호스트 컴퓨터의 터미널 창에서

   1. `nano` 등의 텍스트 편집기를 엽니다.

   1. 이 JSON 문서를 복사하여 열려 있는 텍스트 편집기에 붙여 넣습니다.

      ```
      {
        "endpoint": "a3qEXAMPLEaffp-ats.iot.us-west-2.amazonaws.com",
        "cert": "~/certs/jobs/device.pem.crt",
        "key": "~/certs/jobs/private.pem.key",
        "root-ca": "~/certs/AmazonRootCA1.pem",
        "thing-name": "uniqueThingName",
        "logging": {
          "enable-sdk-logging": true,
          "level": "DEBUG",
          "type": "STDOUT",
          "file": ""
        },
        "jobs": {
          "enabled": true,
          "handler-directory": ""
        },
        "tunneling": {
          "enabled": false
        },
        "device-defender": {
          "enabled": false,
          "interval": 300
        },
        "fleet-provisioning": {
          "enabled": false,
          "template-name": "",
          "template-parameters": "",
          "csr-file": "",
          "device-key": ""
        },
        "samples": {
          "pub-sub": {
            "enabled": false,
            "publish-topic": "",
            "publish-file": "",
            "subscribe-topic": "",
            "subscribe-file": ""
          }
        },
        "config-shadow": {
          "enabled": false
        },
        "sample-shadow": {
          "enabled": false,
          "shadow-name": "",
          "shadow-input-file": "",
          "shadow-output-file": ""
        }
      }
      ```

   1. *엔드포인트* 값을에서 찾 AWS 계정 은의 디바이스 데이터 엔드포인트 값으로 바꿉니다[에서 디바이스 프로비저닝 AWS IoT Core](iot-dc-install-provision.md#iot-dc-install-dc-provision).

   1. *uniqueThingName*을 이 디바이스에 사용한 사물 이름으로 바꿉니다.

   1. 텍스트 편집기에서 파일을 **\$1/dc-configs/dc-jobs-config.json**으로 저장합니다.

1. 이 명령을 실행하여 새로운 구성 파일의 파일 권한을 설정합니다.

   ```
   chmod 644 ~/dc-configs/dc-jobs-config.json
   ```

이 테스트에는 **MQTT 테스트 클라이언트(MQTT test client)**를 사용하지 않습니다. 디바이스가 작업 관련 MQTT 메시지를와 교환하는 동안 AWS IoT작업 진행률 메시지는 작업을 실행하는 디바이스와만 교환됩니다. 작업 진행률 메시지는 작업을 실행하는 디바이스와만 교환되므로 AWS IoT 콘솔과 같은 다른 디바이스에서 메시지를 구독할 수 없습니다.

구성 파일을 저장한 후에는 [AWS IoT Device Client를 AWS IoT 사용하여에서 작업 생성 및 실행](iot-dc-runjobs-prepare-define.md) 단계를 진행할 준비가 된 것입니다.

# AWS IoT Device Client를 AWS IoT 사용하여에서 작업 생성 및 실행
<a name="iot-dc-runjobs-prepare-define"></a>

이 섹션의 절차에서는 작업 문서와 AWS IoT 작업 리소스를 생성합니다. 작업 리소스를 생성한 후는 작업 에이전트가 작업 문서를 디바이스 또는 클라이언트에 적용하는 지정된 작업 대상으로 작업 문서를 AWS IoT 보냅니다.

**Topics**
+ [IoT 작업의 작업 문서 생성 및 저장](#iot-dc-runjobs-prepare-define-jobdoc)
+ [하나의 IoT 디바이스에 AWS IoT 대해에서 작업 실행](#iot-dc-runjobs-prepare-define-job)

## IoT 작업의 작업 문서 생성 및 저장
<a name="iot-dc-runjobs-prepare-define-jobdoc"></a>

이 절차에서는 작업 리소스에 포함할 간단한 AWS IoT 작업 문서를 생성합니다. 이 작업 문서는 작업 대상에서 “Hello world\$1”를 표시합니다.

**작업 문서를 생성하고 저장하려면**

1. 작업 문서를 저장할 Amazon S3 버킷을 선택합니다. 이를 위해 사용할 기존 Amazon S3 버킷이 없는 경우에는 버킷을 생성해야 합니다. Amazon S3 버킷을 생성하는 방법에 대한 자세한 내용은 [Amazon S3 시작하기](https://docs.aws.amazon.com//AmazonS3/latest/userguide/GetStartedWithS3.html)의 주제를 참조하세요.

1. 이 작업에 대한 작업 문서 생성 및 저장

   1. 로컬 호스트 컴퓨터에서 텍스트 편집기를 엽니다.

   1. 이 텍스트를 복사하여 편집기에 붙여 넣습니다.

      ```
      {
          "operation": "echo",
          "args": ["Hello world!"]
      }
      ```

   1. 로컬 호스트 컴퓨터에서 편집기의 내용을 **hello-world-job.json**이라는 파일에 저장합니다.

   1. 파일이 올바르게 저장되었는지 확인합니다. 일부 텍스트 편집기는 텍스트 파일을 저장할 때 파일 이름에 자동으로 `.txt`를 추가합니다. 편집기에서 파일 이름에 `.txt`를 추가한 경우 계속하기 전에 파일 이름을 수정합니다.

1. *path\$1to\$1file*을 **hello-world-job.json**의 경로로 바꾸고(현재 디렉터리에 없는 경우) *s3\$1bucket\$1name*을 선택한 버킷에 대한 Amazon S3 버킷 경로로 바꾼 다음 이 명령을 실행하여 작업 문서를 Amazon S3 버킷에 넣습니다.

   ```
   aws s3api put-object \
   --key hello-world-job.json \
   --body path_to_file/hello-world-job.json --bucket s3_bucket_name
   ```

   Amazon S3에 저장한 작업 문서를 식별하는 작업 문서 URL은 다음 URL에서 *s3\$1bucket\$1name* 및 *AWS\$1region*을 바꿔서 결정됩니다. 나중에 *job\$1document\$1path*로 사용할 결과 URL을 기록합니다.

   ```
   https://s3_bucket_name.s3.AWS_Region.amazonaws.com/hello-world-job.json
   ```
**참고**  
AWS 보안은 AWS 계정예를 들어 브라우저를 사용하여 외부에서이 URL을 열 수 없도록 합니다. URL은 기본적으로 파일에 액세스할 수 있는 AWS IoT 작업 엔진에서 사용됩니다. 프로덕션 환경에서는 AWS IoT 서비스에 Amazon S3에 저장된 작업 문서에 대한 액세스 권한이 있는지 확인해야 합니다.

작업 문서의 URL을 저장한 후 [하나의 IoT 디바이스에 AWS IoT 대해에서 작업 실행](#iot-dc-runjobs-prepare-define-job)으로 진행합니다.

## 하나의 IoT 디바이스에 AWS IoT 대해에서 작업 실행
<a name="iot-dc-runjobs-prepare-define-job"></a>

이 섹션의 절차는 Raspberry Pi에서 AWS IoT Device Client를 시작하여 디바이스에서 작업 에이전트를 실행하고 작업이 실행될 때까지 기다립니다. 또한에서 작업 리소스를 생성 AWS IoT하여 IoT 디바이스로 작업을 전송하고 실행합니다.

**참고**  
이 절차는 단일 디바이스에서만 작업을 실행합니다.

**Raspberry Pi에서 작업 에이전트를 시작하려면**

1. Raspberry Pi에 연결된 로컬 호스트 컴퓨터의 터미널 창에서이 명령을 실행하여 AWS IoT Device Client를 시작합니다.

   ```
   cd ~/aws-iot-device-client/build
   ./aws-iot-device-client --config-file ~/dc-configs/dc-jobs-config.json
   ```

1. 터미널 창에서 AWS IoT Device Client 및가 이러한 메시지를 표시하는지 확인합니다.

   ```
   2021-11-15T18:45:56.708Z [INFO]  {Main.cpp}: Jobs is enabled
                         .
                         .
                         .
   2021-11-15T18:45:56.708Z [INFO]  {Main.cpp}: Client base has been notified that Jobs has started
   2021-11-15T18:45:56.708Z [INFO]  {JobsFeature.cpp}: Running Jobs!
   2021-11-15T18:45:56.708Z [DEBUG] {JobsFeature.cpp}: Attempting to subscribe to startNextPendingJobExecution accepted and rejected
   2021-11-15T18:45:56.708Z [DEBUG] {JobsFeature.cpp}: Attempting to subscribe to nextJobChanged events
   2021-11-15T18:45:56.708Z [DEBUG] {JobsFeature.cpp}: Attempting to subscribe to updateJobExecutionStatusAccepted for jobId +
   2021-11-15T18:45:56.738Z [DEBUG] {JobsFeature.cpp}: Ack received for SubscribeToUpdateJobExecutionAccepted with code {0}
   2021-11-15T18:45:56.739Z [DEBUG] {JobsFeature.cpp}: Attempting to subscribe to updateJobExecutionStatusRejected for jobId +
   2021-11-15T18:45:56.753Z [DEBUG] {JobsFeature.cpp}: Ack received for SubscribeToNextJobChanged with code {0}
   2021-11-15T18:45:56.760Z [DEBUG] {JobsFeature.cpp}: Ack received for SubscribeToStartNextJobRejected with code {0}
   2021-11-15T18:45:56.776Z [DEBUG] {JobsFeature.cpp}: Ack received for SubscribeToStartNextJobAccepted with code {0}
   2021-11-15T18:45:56.776Z [DEBUG] {JobsFeature.cpp}: Ack received for SubscribeToUpdateJobExecutionRejected with code {0}
   2021-11-15T18:45:56.777Z [DEBUG] {JobsFeature.cpp}: Publishing startNextPendingJobExecutionRequest
   2021-11-15T18:45:56.785Z [DEBUG] {JobsFeature.cpp}: Ack received for StartNextPendingJobPub with code {0}
   2021-11-15T18:45:56.785Z [INFO]  {JobsFeature.cpp}: No pending jobs are scheduled, waiting for the next incoming job
   ```

1. 터미널 창에서 이 메시지가 표시되면 다음 절차로 진행하고 작업 리소스를 생성합니다. 목록의 마지막 항목이 아닐 수도 있습니다.

   ```
   2021-11-15T18:45:56.785Z [INFO]  {JobsFeature.cpp}: No pending jobs are scheduled, waiting for the next incoming job
   ```

**AWS IoT 작업 리소스를 생성하려면**

1. 로컬 호스트 컴퓨터에서

   1. *job\$1document\$1url*을 [IoT 작업의 작업 문서 생성 및 저장](#iot-dc-runjobs-prepare-define-jobdoc)의 작업 문서 URL로 바꿉니다.

   1. *thing\$1arn*을 디바이스에 대해 생성한 사물 리소스의 ARN으로 바꾼 다음 이 명령을 실행합니다.

      ```
      aws iot create-job \
      --job-id hello-world-job-1 \
      --document-source "job_document_url" \
      --targets "thing_arn" \
      --target-selection SNAPSHOT
      ```

      성공하면 명령이 다음과 같은 결과를 반환합니다.

      ```
      {
        "jobArn": "arn:aws:iot:us-west-2:57EXAMPLE833:job/hello-world-job-1",
        "jobId": "hello-world-job-1"
      }
      ```

1. 터미널 창에 다음과 같이 AWS IoT Device Client의 출력이 표시됩니다.

   ```
   2021-11-15T18:02:26.688Z [INFO]  {JobsFeature.cpp}: No pending jobs are scheduled, waiting for the next incoming job
   2021-11-15T18:10:24.890Z [DEBUG] {JobsFeature.cpp}: Job ids differ
   2021-11-15T18:10:24.890Z [INFO]  {JobsFeature.cpp}: Executing job: hello-world-job-1
   2021-11-15T18:10:24.890Z [DEBUG] {JobsFeature.cpp}: Attempting to update job execution status!
   2021-11-15T18:10:24.890Z [DEBUG] {JobsFeature.cpp}: Not including stdout with the status details
   2021-11-15T18:10:24.890Z [DEBUG] {JobsFeature.cpp}: Not including stderr with the status details
   2021-11-15T18:10:24.890Z [DEBUG] {JobsFeature.cpp}: Assuming executable is in PATH
   2021-11-15T18:10:24.890Z [INFO]  {JobsFeature.cpp}: About to execute: echo Hello world!
   2021-11-15T18:10:24.890Z [DEBUG] {Retry.cpp}: Retryable function starting, it will retry until success
   2021-11-15T18:10:24.890Z [DEBUG] {JobsFeature.cpp}: Created EphermalPromise for ClientToken 3TEWba9Xj6 in the updateJobExecution promises map
   2021-11-15T18:10:24.890Z [DEBUG] {JobEngine.cpp}: Child process now running
   2021-11-15T18:10:24.890Z [DEBUG] {JobEngine.cpp}: Child process about to call execvp
   2021-11-15T18:10:24.890Z [DEBUG] {JobEngine.cpp}: Parent process now running, child PID is 16737
   2021-11-15T18:10:24.891Z [DEBUG] {16737}: Hello world!
   2021-11-15T18:10:24.891Z [DEBUG] {JobEngine.cpp}: JobEngine finished waiting for child process, returning 0
   2021-11-15T18:10:24.891Z [INFO]  {JobsFeature.cpp}: Job exited with status: 0
   2021-11-15T18:10:24.891Z [INFO]  {JobsFeature.cpp}: Job executed successfully!
   2021-11-15T18:10:24.891Z [DEBUG] {JobsFeature.cpp}: Attempting to update job execution status!
   2021-11-15T18:10:24.891Z [DEBUG] {JobsFeature.cpp}: Not including stdout with the status details
   2021-11-15T18:10:24.891Z [DEBUG] {JobsFeature.cpp}: Not including stderr with the status details
   2021-11-15T18:10:24.892Z [DEBUG] {Retry.cpp}: Retryable function starting, it will retry until success
   2021-11-15T18:10:24.892Z [DEBUG] {JobsFeature.cpp}: Created EphermalPromise for ClientToken GmQ0HTzWGg in the updateJobExecution promises map
   2021-11-15T18:10:24.905Z [DEBUG] {JobsFeature.cpp}: Ack received for PublishUpdateJobExecutionStatus with code {0}
   2021-11-15T18:10:24.905Z [DEBUG] {JobsFeature.cpp}: Removing ClientToken 3TEWba9Xj6 from the updateJobExecution promises map
   2021-11-15T18:10:24.905Z [DEBUG] {JobsFeature.cpp}: Success response after UpdateJobExecution for job hello-world-job-1
   2021-11-15T18:10:24.917Z [DEBUG] {JobsFeature.cpp}: Ack received for PublishUpdateJobExecutionStatus with code {0}
   2021-11-15T18:10:24.918Z [DEBUG] {JobsFeature.cpp}: Removing ClientToken GmQ0HTzWGg from the updateJobExecution promises map
   2021-11-15T18:10:24.918Z [DEBUG] {JobsFeature.cpp}: Success response after UpdateJobExecution for job hello-world-job-1
   2021-11-15T18:10:25.861Z [INFO]  {JobsFeature.cpp}: No pending jobs are scheduled, waiting for the next incoming job
   ```

1.  AWS IoT Device Client가 실행 중이고 작업을 기다리는 동안 `job-id` 값을 변경하고 1단계**create-job**에서를 다시 실행하여 다른 작업을 제출할 수 있습니다.

작업 실행이 완료되면 터미널 창에서 ^C (control-C)를 입력하여 AWS IoT Device Client를 중지합니다.

# 자습서: AWS IoT Device Client 자습서를 실행한 후 정리
<a name="iot-dc-cleanup"></a>

이 튜토리얼의 절차는 이 학습 경로의 튜토리얼을 완료하는 동안 생성한 파일과 리소스를 제거하는 과정을 안내합니다.

**Topics**
+ [1단계: Device Client로 데모를 빌드한 후 AWS IoT 디바이스 정리](#iot-dc-cleanup-devices)
+ [2단계: AWS IoT Device Client로 데모를 빌드한 AWS 계정 후 정리](#iot-dc-cleanup-cloud)

## 1단계: Device Client로 데모를 빌드한 후 AWS IoT 디바이스 정리
<a name="iot-dc-cleanup-devices"></a>

이 튜토리얼에서는 이 학습 경로에서 데모를 빌드한 후 microSD 카드를 정리하는 방법에 대한 두 가지 옵션을 설명합니다. 필요한 보안 수준을 제공하는 옵션을 선택합니다.

디바이스의 microSD 카드를 정리해도 생성한 AWS IoT 리소스는 제거되지 않습니다. 디바이스의 microSD 카드를 정리한 후 AWS IoT 리소스를 정리하려면의 자습서를 검토해야 합니다[2단계: AWS IoT Device Client로 데모를 빌드한 AWS 계정 후 정리](#iot-dc-cleanup-cloud).

### 옵션 1: microSD 카드를 다시 써서 정리
<a name="iot-dc-cleanup-devices-flash"></a>

이 학습 경로의 튜토리얼을 완료한 후 microSD 카드를 지우는 가장 쉽고 철저한 방법은 디바이스를 처음 준비할 때 생성한 저장된 이미지 파일로 microSD 카드를 덮어쓰는 것입니다.

이 절차에서는 로컬 호스트 컴퓨터를 사용하여 저장된 microSD 카드 이미지를 microSD 카드에 씁니다.

**참고**  
디바이스에서 운영 체제에 이동식 저장 매체를 사용하지 않는 경우 해당 디바이스에 대한 절차를 참조하세요.

**microSD 카드에 새 이미지를 쓰려면**

1. 로컬 호스트 컴퓨터에서 microSD 카드에 쓸 저장된 microSD 카드 이미지를 찾습니다.

1. microSD 카드를 로컬 호스트 컴퓨터에 삽입합니다.

1. SD 카드 이미징 도구를 사용하여 선택한 이미지 파일을 microSD 카드에 씁니다.

1. Raspberry Pi OS 이미지를 microSD 카드에 쓴 후 microSD 카드를 꺼내 로컬 호스트 컴퓨터에서 안전하게 제거합니다.

microSD 카드를 사용할 준비가 되었습니다.

### 옵션 2: 사용자 디렉터리를 삭제하여 정리
<a name="iot-dc-cleanup-devices-dirs"></a>

튜토리얼을 완료한 후 microSD 카드 이미지를 다시 쓰지 않고 microSD 카드를 지우려면 사용자 디렉터리를 개별적으로 삭제합니다. 이 방법은 설치되었을 수 있는 시스템 파일을 제거하지 않기 때문에 저장된 이미지에서 microSD 카드를 다시 쓰는 것만큼 철저하지 않습니다.

사용자 디렉터리 제거만으로도 충분하다면 이 절차를 따를 수 있습니다.

**디바이스에서 이 학습 경로의 사용자 디렉터리를 삭제하려면**

1. 이 명령을 실행하여 디바이스에 연결된 터미널 창에서 이 학습 경로에 생성된 사용자 디렉터리, 하위 디렉터리 및 모든 파일을 삭제합니다.
**참고**  
이러한 디렉터리와 파일을 삭제하면 튜토리얼을 다시 완료하지 않고 데모를 실행할 수 없게 됩니다.

   ```
   rm -Rf ~/dc-configs
   rm -Rf ~/policies
   rm -Rf ~/messages
   rm -Rf ~/certs
   rm -Rf ~/.aws-iot-device-client
   ```

1. 이 명령을 실행하여 디바이스에 연결된 터미널 창에서 애플리케이션 소스 디렉터리 및 파일을 삭제합니다.
**참고**  
이 명령은 프로그램을 제거하지 않습니다. 프로그램 빌드 및 설치에 사용된 소스 파일만 제거합니다. 이러한 파일을 삭제한 후에는 AWS CLI 및 AWS IoT Device Client가 작동하지 않을 수 있습니다.

   ```
   rm -Rf ~/aws-cli
   rm -Rf ~/aws
   rm -Rf ~/aws-iot-device-client
   ```

## 2단계: AWS IoT Device Client로 데모를 빌드한 AWS 계정 후 정리
<a name="iot-dc-cleanup-cloud"></a>

이 절차는이 학습 경로의 자습서를 완료하는 동안 생성한 AWS 리소스를 식별하고 제거하는 데 도움이 됩니다.

### AWS IoT 리소스 정리
<a name="iot-dc-cleanup-cloud-iot"></a>

이 절차는이 학습 경로의 자습서를 완료하는 동안 생성한 AWS IoT 리소스를 식별하고 제거하는 데 도움이 됩니다.


**AWS IoT 이 학습 경로에 생성된 리소스**  

| 자습서 | 사물 리소스 | 정책 리소스 | 
| --- | --- | --- | 
|  [자습서: AWS IoT Device Client 설치 및 구성](iot-dc-install-dc.md)  |  **DevCliTestThing**  | DevCliTestThingPolicy | 
|  [자습서: AWS IoT Device Client와의 MQTT 메시지 통신 시연](iot-dc-testconn.md)  |  **PubSubTestThing**  | PubSubTestThingPolicy | 
|  [자습서: AWS IoT Device Client를 사용하여 원격 작업(작업) 시연](iot-dc-runjobs.md)  | 사용자 정의(여러 개 있을 수 있음) |  *사용자 정의*(여러 개 있을 수 있음)  | 

**AWS IoT 리소스를 삭제하려면 생성한 각 사물 리소스에 대해이 절차를 따릅니다.**

1. `thing_name`을 삭제하려는 사물 리소스의 이름으로 바꾼 다음 이 명령을 실행하여 로컬 호스트 컴퓨터에서 사물 리소스에 연결된 인증서를 나열합니다.

   ```
   aws iot list-thing-principals --thing-name thing_name
   ```

   이 명령은 연결된 인증서를 나열하는 이와 같은 응답을 반환합니다.`thing_name` 대부분의 경우 목록에 인증서가 하나만 있습니다.

   ```
   {
       "principals": [
           "arn:aws:iot:us-west-2:57EXAMPLE833:cert/23853eea3cf0edc7f8a69c74abeafa27b2b52823cab5b3e156295e94b26ae8ac"
       ]
   }
   ```

1. 이전 명령으로 나열된 각 인증서에 대해

   1. `certificate_ID`를 이전 명령의 인증서 ID로 바꿉니다. 인증서 ID는 이전 명령에서 반환된 ARN에서 `cert/` 뒤에 오는 영숫자 문자입니다. 그런 다음 이 명령을 실행하여 인증서를 비활성화합니다.

      ```
      aws iot update-certificate --new-status INACTIVE --certificate-id certificate_ID
      ```

      성공한 경우 이 명령은 아무 것도 반환하지 않습니다.

   1. `certificate_ARN`을 이전에 반환된 인증서 목록의 인증서 ARN으로 바꾼 다음 이 명령을 실행하여 이 인증서에 연결된 정책을 나열합니다.

      ```
      aws iot list-attached-policies --target certificate_ARN
      ```

      이 명령은 인증서에 연결된 정책을 나열하는 이와 같은 응답을 반환합니다. 대부분의 경우 목록에 정책이 하나만 있습니다.

      ```
      {
          "policies": [
              {
                  "policyName": "DevCliTestThingPolicy",
                  "policyArn": "arn:aws:iot:us-west-2:57EXAMPLE833:policy/DevCliTestThingPolicy"
              }
          ]
      }
      ```

   1. 인증서에 연결된 각 정책에 대해:

      1. `policy_name`을 이전 명령의 `policyName` 값으로 바꾸고 `certificate_ARN`을 인증서 ARN으로 바꾼 다음 이 명령을 실행하여 인증서에서 정책을 분리합니다.

         ```
         aws iot detach-policy --policy-name policy_name --target certificate_ARN
         ```

         성공한 경우 이 명령은 아무 것도 반환하지 않습니다.

      1. `policy_name`을 `policyName` 값으로 바꾼 다음 이 명령을 실행하여 정책이 추가 인증서에 연결되어 있는지 확인합니다.

         ```
         aws iot list-targets-for-policy --policy-name policy_name
         ```

         명령이 이와 같은 빈 목록을 반환하는 경우 정책은 인증서에 연결되지 않은 것입니다. 계속해서 정책 버전을 나열합니다. 정책에 연결된 인증서가 여전히 있는 경우 **detach-thing-principal** 단계를 계속합니다.

         ```
         {
             "targets": []
         }
         ```

      1. `policy_name`을 `policyName` 값으로 바꾼 다음 이 명령을 실행하여 정책 버전을 확인합니다. 정책을 삭제하려면 버전이 하나만 있어야 합니다.

         ```
         aws iot list-policy-versions --policy-name policy_name
         ```

         이 예와 같이 정책에 버전이 하나만 있는 경우 지금 **delete-policy** 단계로 건너뛰고 정책을 삭제할 수 있습니다.

         ```
         {
             "policyVersions": [
                 {
                     "versionId": "1",
                     "isDefaultVersion": true,
                     "createDate": "2021-11-18T01:02:46.778000+00:00"
                 }
             ]
         }
         ```

         이 예와 같이 정책에 여러 버전이 있는 경우 `isDefaultVersion` 값이 `false`인 정책 버전을 삭제해야 정책을 삭제할 수 있습니다.

         ```
         {
             "policyVersions": [
                 {
                     "versionId": "2",
                     "isDefaultVersion": true,
                     "createDate": "2021-11-18T01:52:04.423000+00:00"
                 },
                 {
                     "versionId": "1",
                     "isDefaultVersion": false,
                     "createDate": "2021-11-18T01:30:18.083000+00:00"
                 }
             ]
         }
         ```

         정책 버전을 삭제해야 하는 경우 `policy_name`을 `policyName` 값으로 바꾸고 `version_ID`를 이전 명령의 `versionId` 값으로 바꾼 다음 이 명령을 실행하여 정책 버전을 삭제합니다.

         ```
         aws iot delete-policy-version --policy-name policy_name --policy-version-id version_ID
         ```

         성공한 경우 이 명령은 아무 것도 반환하지 않습니다.

         정책 버전을 삭제한 후 정책에 정책 버전이 하나만 있을 때까지 이 단계를 반복합니다.

      1. `policy_name`을 `policyName` 값으로 바꾼 다음 이 명령을 실행하여 정책을 삭제합니다.

         ```
         aws iot delete-policy --policy-name policy_name
         ```

   1. `thing_name`을 사물의 이름으로 바꾸고 `certificate_ARN`을 인증서의 ARN으로 바꾼 다음, 이 명령을 실행하여 사물 리소스에서 인증서를 분리합니다.

      ```
      aws iot detach-thing-principal --thing-name thing_name --principal certificate_ARN
      ```

      성공한 경우 이 명령은 아무 것도 반환하지 않습니다.

   1. `certificate_ID`를 이전 명령의 인증서 ID로 바꿉니다. 인증서 ID는 이전 명령에서 반환된 ARN에서 `cert/` 뒤에 오는 영숫자 문자입니다. 그런 다음 이 명령을 실행하여 인증서 리소스를 삭제합니다.

      ```
      aws iot delete-certificate --certificate-id certificate_ID
      ```

      성공한 경우 이 명령은 아무 것도 반환하지 않습니다.

1. `thing_name`을 사물의 이름으로 바꾼 다음 이 명령을 실행하여 사물을 삭제합니다.

   ```
   aws iot delete-thing --thing-name thing_name
   ```

   성공한 경우 이 명령은 아무 것도 반환하지 않습니다.

### AWS 리소스 정리
<a name="iot-dc-cleanup-cloud-aws"></a>

이 절차는이 학습 경로의 자습서를 완료하는 동안 생성한 다른 AWS 리소스를 식별하고 제거하는 데 도움이 됩니다.


**이 학습 경로에 생성된 기타 AWS 리소스**  

| 자습서 | 리소스 유형 | 리소스 이름 또는 ID | 
| --- | --- | --- | 
|  [자습서: AWS IoT Device Client를 사용하여 원격 작업(작업) 시연](iot-dc-runjobs.md)  | Amazon S3 객체 | hello-world-job.json | 
|  [자습서: AWS IoT Device Client를 사용하여 원격 작업(작업) 시연](iot-dc-runjobs.md)  |  AWS IoT 작업 리소스  | 사용자 정의 | 

**이 학습 경로에서 생성된 AWS 리소스를 삭제하려면**

1. 이 학습 경로에서 생성된 작업을 삭제하려면

   1. 이 명령을 실행하여의 작업을 나열합니다 AWS 계정.

      ```
      aws iot list-jobs
      ```

      명령은 다음과 AWS 리전 같은 및의 AWS IoT 작업 목록을 반환합니다 AWS 계정 .

      ```
      {
          "jobs": [
              {
                  "jobArn": "arn:aws:iot:us-west-2:57EXAMPLE833:job/hello-world-job-2",
                  "jobId": "hello-world-job-2",
                  "targetSelection": "SNAPSHOT",
                  "status": "COMPLETED",
                  "createdAt": "2021-11-16T23:40:36.825000+00:00",
                  "lastUpdatedAt": "2021-11-16T23:40:41.375000+00:00",
                  "completedAt": "2021-11-16T23:40:41.375000+00:00"
              },
              {
                  "jobArn": "arn:aws:iot:us-west-2:57EXAMPLE833:job/hello-world-job-1",
                  "jobId": "hello-world-job-1",
                  "targetSelection": "SNAPSHOT",
                  "status": "COMPLETED",
                  "createdAt": "2021-11-16T23:35:26.381000+00:00",
                  "lastUpdatedAt": "2021-11-16T23:35:29.239000+00:00",
                  "completedAt": "2021-11-16T23:35:29.239000+00:00"
              }
          ]
      }
      ```

   1. 목록에서이 학습 경로에서 생성한 작업으로 인식하는 각 작업에 대해를 삭제할 작업의 `jobId` 값으로 `jobId` 바꾼 다음이 명령을 실행하여 AWS IoT 작업을 삭제합니다.

      ```
      aws iot delete-job --job-id jobId
      ```

      명령이 성공하면 아무 것도 반환하지 않습니다.

1. 이 학습 경로의 Amazon S3 버킷에 저장한 작업 문서를 삭제하려면

   1. `bucket`을 사용한 버킷의 이름으로 바꾼 다음 이 명령을 실행하여 사용한 Amazon S3 버킷의 객체를 나열합니다.

      ```
      aws s3api list-objects --bucket bucket
      ```

      이 명령은 다음과 같은 버킷의 Amazon S3 객체 목록을 반환합니다.

      ```
      {
          "Contents": [
              {
                  "Key": "hello-world-job.json",
                  "LastModified": "2021-11-18T03:02:12+00:00",
                  "ETag": "\"868c8bc3f56b5787964764d4b18ed5ef\"",
                  "Size": 54,
                  "StorageClass": "STANDARD",
                  "Owner": {
                      "DisplayName": "EXAMPLE",
                      "ID": "e9e3d6ec1EXAMPLEf5bfb5e6bd0a2b6ed03884d1ed392a82ad011c144736a4ee"
                  }
              },
              {
                  "Key": "iot_job_firmware_update.json",
                  "LastModified": "2021-04-13T21:57:07+00:00",
                  "ETag": "\"7c68c591949391791ecf625253658c61\"",
                  "Size": 66,
                  "StorageClass": "STANDARD",
                  "Owner": {
                      "DisplayName": "EXAMPLE",
                      "ID": "e9e3d6ec1EXAMPLEf5bfb5e6bd0a2b6ed03884d1ed392a82ad011c144736a4ee"
                  }
              },
              {
                  "Key": "order66.json",
                  "LastModified": "2021-04-13T21:57:07+00:00",
                  "ETag": "\"bca60d5380b88e1a70cc27d321caba72\"",
                  "Size": 29,
                  "StorageClass": "STANDARD",
                  "Owner": {
                      "DisplayName": "EXAMPLE",
                      "ID": "e9e3d6ec1EXAMPLEf5bfb5e6bd0a2b6ed03884d1ed392a82ad011c144736a4ee"
                  }
              }
          ]
      }
      ```

   1. 목록에서 이 학습 경로에서 생성한 객체로 인식한 각 객체에 대해 `bucket`을 버킷 이름으로 바꾸고, `key`를 삭제할 객체의 키 값으로 바꾼 다음 이 명령을 실행하여 Amazon S3 객체를 삭제합니다.

      ```
       aws s3api delete-object --bucket bucket --key key
      ```

      명령이 성공하면 아무 것도 반환하지 않습니다.

이 학습 경로를 완료하는 동안 생성한 모든 AWS 리소스와 객체를 삭제한 후 자습서를 다시 시작하고 반복할 수 있습니다.