ステップ2：スキルコードを実装する

前のステップでは、Alexa開発者コンソールで新しいスマートホームスキルを作成しました。次は、スマートホームスキルのコードをアマゾンウェブサービス（AWS）のLambda関数として実装します。この関数は、スキルコード、設定情報、Identity and Access Management（IAM）ロールで構成されます。IAMロールは、ユーザーに代わってスキルコードを実行する許可をLambdaに与えます。Lambda関数では、オプションでデータをAWS DynamoDBに保存したり、ログをAWS CloudWatchに書き込んだりできます。

コードは、AWS Lambdaコンソールで直接作成することも、スキルのコード作成に使用するプログラミング言語に最適な開発環境で作成することもできます。Lambda関数は、Node.js、Java、Python、C#、Go、Ruby、PowerShellで作成できます。簡潔にするため、このチュートリアルのステップではAWS Lambdaコンソールのコードエディターを使用し、PythonとNode.jsのコード例を提供します。

チュートリアル：
スマートホームスキルの作成

→

ステップ1：
スキルを作成する

→

ステップ2：
スキルを実装する

→

ステップ3：
サービスエンドポイントを設定する

→

ステップ4：
アカウントリンクを設定する

→

ステップ5：
スキルをテストする

AWSコンソールでのスキルコードの実装手順

仮想電球を制御するスキルコードを実装するには、以下の手順を実行します。

IAMロールを作成する
Lambda関数を作成する
スキルコードを追加する
Lambda関数をテストする
リソース名をコピーする

手順2.1： IAMロールを作成する

この手順では、新しいIAMロールにスマートホームポリシーをアタッチします。ステップbでは、Lambda関数にロールを割り当てます。

注：以降の手順では、再設計されたIAMロールページを使用します。

AWS開発者コンソールでAWS Lambda関数のIAMロールを作成するには

AWSマネジメントコンソールにサインインします。
IAMダッシュボードを開きます。
IAMダッシュボードで、左側のメニューからアクセス管理のロールをクリックします。
IAM＞ロールページで、ロールの作成をクリックします。
IAM＞ロール＞ロールの作成ページで、次の情報を入力します。
1. 信頼されたエンティティを選択の信頼されたエンティティタイプで、AWSのサービスを選択します。
2. ユースケースでLambdaを選択し、次へをクリックします。
許可を追加で、AWSLambdaBasicExecutionRoleというポリシーをフィルタリングして見つけます。
AWSLambdaBasicExecutionRoleというポリシーとAWS管理というタイプの横にあるチェックボックスをオンにし、次へをクリックします。
名前、確認、および作成ページのロール名に、「lambda_smart_home_skill_role」と入力し、ページの下部にあるロールを作成をクリックします。

これで、使用可能なロールのリストにlambda_smart_home_skill_roleが表示されます。

手順2.2： Lambda関数を作成する

この手順では、Lambda関数を作成し、IAMロールを追加して、Lambdaが開発者に代わってコードを実行できるようにします。その後、サンプルスキルコードを追加します。

AWS開発者コンソールでAWS Lambda関数を作成するには

Lambdaダッシュボードに移動します。Lambda関数を作成したことがある場合、コンソールには関数のリストが表示されます。
AWS Lambdaページで、関数の作成をクリックします。
関数の作成をクリックします。
注：コンソールの右上隅には、Lambda関数が配置されているAWSリージョンが表示されます。このチュートリアルでは、北米リージョン（AWS米国東部（バージニア北部）（us-east-1）リージョン）と英語（米国）を使用します。北米以外でスキルを実行する場合は、別のAWSリージョンおよび言語を選択します。詳細については、AWS LambdaリージョンおよびLambda関数を複数のリージョンにデプロイするを参照してください。
関数の作成で、一から作成を選択します。
基本情報で、次の情報を入力します。
1. 関数名に、「my-smart-home-skill」と入力します。
2. ランタイムで、PythonまたはNode.jsのバージョンを選択します。
3. アーキテクチャはデフォルトのままにします。
4. アクセス権限＞デフォルトの実行ロールの変更で、既存のロールを使用するを選択します。
5. 既存のロールで、lambda_smart_home_skill_roleを選択し、関数の作成をクリックします。
Lambda＞関数＞my-smart-home-skillページで、関数の概要の＋トリガーを追加をクリックします。
トリガーを追加ページで、スキルをトリガーするための以下の情報を入力します。
1. トリガーの設定で、Alexaを選択します。
2. Alexa製品を選択で、Alexa Smart Homeを選択します。
3. スキルID検証で、有効（推奨）を選択します。
4. スキルIDに、ステップ1：スマートホームスキルを作成するで保存したスキルIDを貼り付けます。
5. スキルを呼び出すトリガーを追加するには、追加をクリックします。

手順2.3：スキルコードを追加する

次に、サンプルスキルコードをLambda関数に追加します。サンプルコードには、電球をモデル化する検出応答と、電球を制御するAlexa応答が含まれています。Alexaからディレクティブを受信すると、Lambda関数がスキルコードを実行します。

検出応答は、電球のエンドポイントを識別し、製造元、モデル、シリアル番号など、エンドポイントに関する識別情報をできるだけ多く含めます。さらに、検出応答は電球の機能を識別します。この例では、応答にAlexa.PowerControllerインターフェースが含まれており、ユーザーが電球をオンまたはオフできることを示しています。検出の詳細については、Alexa検出についてを参照してください。

ユーザーがAlexaに電球をつけるように指示すると、AlexaはTurnOnディレクティブをスキルに送信します。これに応答して、スキルはデバイス制御クラウドの適切なインターフェースを呼び出して電球をオンにし、電球エンドポイントの現在の状態をAlexaに返します。

フル機能のスマートホームスキルには、エンドポイントデバイスの機能を最も適切に表す機能インターフェースの組み合わせが含まれる場合があります。また、スキルは通常、Alexaがデバイスのステータスを最新に保てるようにするために、状態および変更レポートをサポートしています。使用可能なスマートホームインターフェイスを使用してデバイスタイプをモデル化する方法については、Alexaインターフェースとサポートしている言語の一覧を参照してください。

スキルコードをLambda関数に追加する

Lambda＞関数＞my-smart-home-skillページで、コードタブをクリックしてソースコードを表示します。
Pythonの場合、スキルコードはlambda_function.pyファイルにあります。Node.jsの場合、スキルコードはindex.jsファイルまたはindex.mjsファイルにあります。このチュートリアルでは、index.mjsの名前をindex.jsに変更します。
関数コードを表示するには、lambda_function.pyまたはindex.jsをクリックします。
既存のコードを、仮想電球を制御する以下のスマートホームスキルコードに置き換えます。
このコードはAcceptGrant、Discovery、TurnOn、TurnOffディレクティブをサポートしています。

Node.js
Python

クリップボードにコピーしました。

// -*- coding: utf-8 -*-

// Copyright 2021 Amazon.com, Inc. or its affiliates.All Rights Reserved.
//
// SPDX-License-Identifier: LicenseRef-.amazon.com.-AmznSL-1.0
// アマゾンソフトウェア使用許諾（以下「ライセンス」）で使用許諾されています。
// ライセンスに準拠することなくこのファイルを使用することはできません。
// ライセンスのコピーは、http://aws.amazon.com/asl/で参照できます。
//
// このファイルは「現状有姿」で配布され、
// 明示または黙示を問わず、いかなる種類の保証も条件もありません。ライセンスに基づく許可と制限を
// 規定する特定の言語については、ライセンスを参照してください。

exports.handler = function (request, context) {
    if (request.directive.header.namespace === 'Alexa.Discovery' && request.directive.header.name === 'Discover') {
        log("DEBUG:", "Discover request",  JSON.stringify(request));
        handleDiscovery(request, context, "");
    }
    else if (request.directive.header.namespace === 'Alexa.PowerController') {
        if (request.directive.header.name === 'TurnOn' || request.directive.header.name === 'TurnOff') {
            log("DEBUG:", "TurnOn or TurnOff Request", JSON.stringify(request));
            handlePowerControl(request, context);
        }
    }
    else if (request.directive.header.namespace === 'Alexa.Authorization' && request.directive.header.name === 'AcceptGrant') {
        handleAuthorization(request, context)
    }

    function handleAuthorization(request, context) {
        // AcceptGrant応答を送信します
        var payload = {};
        var header = request.directive.header;
        header.name = "AcceptGrant.Response";
        log("DEBUG", "AcceptGrant Response: ", JSON.stringify({ header: header, payload: payload }));
        context.succeed({ event: { header: header, payload: payload } });
    }

    function handleDiscovery(request, context) {
        // 検出応答を送信します
        var payload = {
            "endpoints":
            [
                {
                    "endpointId": "sample-bulb-01",
                    "manufacturerName": "スマートデバイス株式会社",
                    "friendlyName": "リビングの照明",
                    "description": "仮想スマート電球",
                    "displayCategories": ["LIGHT"],
                    "additionalAttributes":  {
                        "manufacturer" : "サンプルメーカー",
                        "model" : "サンプルモデル",
                        "serialNumber": "U11112233456",
                        "firmwareVersion" : "1.24.2546",
                        "softwareVersion": "1.036",
                        "customIdentifier": "サンプルカスタムID"
                    },
                    "cookie": {
                        "key1": "このエンドポイントを参照するためのスキルの任意のキー／値のペアです。",
                        "key2": "複数のエントリがある場合があります。",
                        "key3": "ただし、参照のためにだけ使用してください。",
                        "key4": "現在のエンドポイントの状態を維持するのに適切な場所ではありません。"
                    },
                    "capabilities":
                    [
                        {
                            "interface": "Alexa.PowerController",
                            "version": "3",
                            "type": "AlexaInterface",
                            "properties": {
                                "supported": [{
                                    "name": "powerState"
                                }],
                                 "retrievable": true
                            }
                        },
                        {
                        "type": "AlexaInterface",
                        "interface": "Alexa.EndpointHealth",
                        "version": "3.2",
                        "properties": {
                            "supported": [{
                                "name": "connectivity"
                            }],
                            "retrievable": true
                        }
                    },
                    {
                        "type": "AlexaInterface",
                        "interface": "Alexa",
                        "version": "3"
                    }
                    ]
                }
            ]
        };
        var header = request.directive.header;
        header.name = "Discover.Response";
        log("DEBUG", "Discovery Response: ", JSON.stringify({ header: header, payload: payload }));
        context.succeed({ event: { header: header, payload: payload } });
    }

    function log(message, message1, message2) {
        console.log(message + message1 + message2);
    }

    function handlePowerControl(request, context) {
        // 検出中に渡されたデバイスIDを取得します
        var requestMethod = request.directive.header.name;
        var responseHeader = request.directive.header;
        responseHeader.namespace = "Alexa";
        responseHeader.name = "Response";
        responseHeader.messageId = responseHeader.messageId + "-R";
        // リクエスト中のユーザートークンパスを取得します
        var requestToken = request.directive.endpoint.scope.token;
        var powerResult;

        if (requestMethod === "TurnOn") {

            // デバイス制御クラウドを呼び出して制御します
            // powerResult = stubControlFunctionToYourCloud(endpointId, token, request);
            powerResult = "ON";
        }
       else if (requestMethod === "TurnOff") {
            // デバイス制御クラウドを呼び出して制御し、成功したかどうか確認します
            // powerResult = stubControlFunctionToYourCloud(endpointId, token, request);
            powerResult = "OFF";
        }
        // 更新されたpowerStateを返します。 Alexa.Responseには必ずEndpointHealthを含めます。
        // timeOfSampleの日時形式はISO 8601で、YYYY-MM-DDThh:mm:ssZとなります。
        var contextResult = {
            "properties": [{
                "namespace": "Alexa.PowerController",
                "name": "powerState",
                "value": powerResult,
                "timeOfSample": "2022-09-03T16:20:50.52Z", //結果から取得します。
                "uncertaintyInMilliseconds": 50
            },
            {
                "namespace": "Alexa.EndpointHealth",
                "name": "connectivity",
                "value": {
                "value": "OK"
            },
            "timeOfSample": "2022-09-03T22:43:17.877738+00:00",
            "uncertaintyInMilliseconds": 0
            }]
        };
        var response = {
            context: contextResult,
            event: {
                header: responseHeader,
                endpoint: {
                    scope: {
                        type: "BearerToken",
                        token: requestToken
                    },
                    endpointId: "sample-bulb-01"
                },
                payload: {}
            }
        };
        log("DEBUG", "Alexa.PowerController ", JSON.stringify(response));
        context.succeed(response);
    }
};

クリップボードにコピーしました。

# -*- coding: utf-8 -*-

# Copyright 2021 Amazon.com, Inc. or its affiliates.All Rights Reserved.
#
# SPDX-License-Identifier: LicenseRef-.amazon.com.-AmznSL-1.0
# アマゾンソフトウェア使用許諾（以下「ライセンス」）で使用許諾されています。
# ライセンスに準拠することなく
# このファイルを使用することはできません。ライセンスのコピーは、http://aws.amazon.com/asl/で参照できます。
#
# このファイルは「現状有姿」で配布され、
# 明示または黙示を問わず、いかなる種類の保証も条件もありません。ライセンスに基づく許可と制限を
# 規定する特定の言語については、ライセンスを参照してください。


import json
import math
import random
import uuid
import logging
import datetime
from datetime import datetime, timezone

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

def lambda_handler(request, context):

    # リクエストをダンプしてログに記録します（CloudWatchログを確認してください）。
    print('lambda_handler request  -----')
    print(json.dumps(request))


    if context is not None:
        print('lambda_handler context  -----')
        print(context)

    # リクエストがAlexaスマートホームディレクティブであることを検証します。
    if 'directive' not in request:
        alexa_response = AlexaResponse(
            name='ErrorResponse',
            payload={'type': 'INVALID_DIRECTIVE',
                     'message': 'キーがありません：directive、リクエストは有効なAlexaディレクティブですか？'})
        return send_response(alexa_response.get())

    # ペイロードのバージョンを確認します。
    payload_version = request['directive']['header']['payloadVersion']
    if payload_version != '3':
        alexa_response = AlexaResponse(
            name='ErrorResponse',
            payload={'type': 'INTERNAL_ERROR',
                     'message': 'このスキルではスマートホームAPIのバージョン3のみがサポートされます'})
        return send_response(alexa_response.get())

    # リクエストを開いて確認します。
    name = request['directive']['header']['name']
    namespace = request['directive']['header']['namespace']

    # 名前空間に基づいてAlexaからの受信リクエストを処理します。
    if namespace == 'Alexa.Authorization':
        if name == 'AcceptGrant':
            # 注： このコード例では、すべてのGrantリクエストを受け入れます。
            # 実装では、Grantコードを使用してLogin with Amazonを呼び出し、アクセストークンと更新トークンを取得してください。
            grant_code = request['directive']['payload']['grant']['code']
            grantee_token = request['directive']['payload']['grantee']['token']
            auth_response = AlexaResponse(namespace='Alexa.Authorization', name='AcceptGrant.Response')
            return send_response(auth_response.get())

    if namespace == 'Alexa.Discovery':
        if name == 'Discover':
            # スキルが制御するデバイスを検出するためのリクエスト。
            discovery_response = AlexaResponse(namespace='Alexa.Discovery', name='Discover.Response')
            # 応答を作成し、電球の機能を追加します。
            capability_alexa = discovery_response.create_payload_endpoint_capability()
            capability_alexa_powercontroller = discovery_response.create_payload_endpoint_capability(
                interface='Alexa.PowerController',
                supported=[{'name': 'powerState'}])
            capability_alexa_endpointhealth = discovery_response.create_payload_endpoint_capability(
                interface='Alexa.EndpointHealth',
                supported=[{'name': 'connectivity'}])
            discovery_response.add_payload_endpoint(
                friendly_name='サンプル電球',
                endpoint_id='sample-bulb-01',
                capabilities=[capability_alexa, capability_alexa_endpointhealth, capability_alexa_powercontroller])
            return send_response(discovery_response.get())

    if namespace == 'Alexa.PowerController':
        # 電球をオンまたはオフにするためのディレクティブ。
        # 注： このコード例では、常に成功応答を返します。
        endpoint_id = request['directive']['endpoint']['endpointId']
        power_state_value = 'OFF' if name == 'TurnOff' else 'ON'
        correlation_token = request['directive']['header']['correlationToken']

        # 状態の設定時にエラーをチェックします。
        device_set = update_device_state(endpoint_id=endpoint_id, state='powerState', value=power_state_value)
        if not device_set:
            return AlexaResponse(
                name='ErrorResponse',
                payload={'type': 'ENDPOINT_UNREACHABLE', 'message': 'エンドポイントデータベースにアクセスできません。'}).get()

        directive_response = AlexaResponse(correlation_token=correlation_token)
        directive_response.add_context_property(namespace='Alexa.PowerController', name='powerState', value=power_state_value)
        return send_response(directive_response.get())

# 応答を送信します
def send_response(response):
    print('lambda_handler response -----')
    print(json.dumps(response))
    return response

# デバイス制御クラウドを呼び出して制御します
def update_device_state(endpoint_id, state, value):
    attribute_key = state + 'Value'
    # result = stubControlFunctionToYourCloud(endpointId, token, request);
    return True

# timeOfSampleの日時形式はISO 8601で、YYYY-MM-DDThh:mm:ssZとなります。
def get_utc_timestamp(seconds=None):
    return datetime.now(timezone.utc).isoformat()

class AlexaResponse:

    def __init__(self, **kwargs):

        self.context_properties = []
        self.payload_endpoints = []

        # 応答の構造を設定します。
        self.context = {}
        self.event = {
            'header': {
                'namespace': kwargs.get('namespace', 'Alexa'),
                'name': kwargs.get('name', 'Response'),
                'messageId': str(uuid.uuid4()),
                'payloadVersion': kwargs.get('payload_version', '3')
            },
            'endpoint': {
                "scope": {
                    "type": "BearerToken",
                    "token": kwargs.get('token', 'INVALID')
                },
                "endpointId": kwargs.get('endpoint_id', 'INVALID')
            },
            'payload': kwargs.get('payload', {})
        }

        if 'correlation_token' in kwargs:
            self.event['header']['correlation_token'] = kwargs.get('correlation_token', 'INVALID')

        if 'cookie' in kwargs:
            self.event['endpoint']['cookie'] = kwargs.get('cookie', '{}')

        # AcceptGrantリクエストまたはDiscoverリクエストにはendpointプロパティはありません。
        if self.event['header']['name'] == 'AcceptGrant.Response' or self.event['header']['name'] == 'Discover.Response':
            self.event.pop('endpoint')

    def add_context_property(self, **kwargs):
        self.context_properties.append(self.create_context_property(**kwargs))
        self.context_properties.append(self.create_context_property())


    def add_cookie(self, key, value):

        if "cookies" in self is None:
            self.cookies = {}

        self.cookies[key] = value

    def add_payload_endpoint(self, **kwargs):
        self.payload_endpoints.append(self.create_payload_endpoint(**kwargs))


    def create_context_property(self, **kwargs):
        return {
            'namespace': kwargs.get('namespace', 'Alexa.EndpointHealth'),
            'name': kwargs.get('name', 'connectivity'),
            'value': kwargs.get('value', {'value': 'OK'}),
            'timeOfSample': get_utc_timestamp(),
            'uncertaintyInMilliseconds': kwargs.get('uncertainty_in_milliseconds', 0)
        }

    def create_payload_endpoint(self, **kwargs):
        # エンドポイントで想定される適切な構造を返します。
        # すべての検出応答にはadditionAttributesを含める必要があります
        additionalAttributes = {
            'manufacturer': kwargs.get('manufacturer', 'サンプルメーカー'),
            'model': kwargs.get('model_name', 'サンプルモデル'),
            'serialNumber': kwargs.get('serial_number', 'U11112233456'),
            'firmwareVersion': kwargs.get('firmware_version', '1.24.2546'),
            'softwareVersion': kwargs.get('software_version', '1.036'),
            'customIdentifier': kwargs.get('custom_identifier', 'サンプルカスタムID')
        }

        endpoint = {
            'capabilities': kwargs.get('capabilities', []),
            'description': kwargs.get('description', 'スマートホームチュートリアル： 仮想スマート電球'),
            'displayCategories': kwargs.get('display_categories', ['LIGHT']),
            'endpointId': kwargs.get('endpoint_id', 'endpoint_' + "%0.6d" % random.randint(0, 999999)),
            'friendlyName': kwargs.get('friendly_name', 'サンプル照明'),
            'manufacturerName': kwargs.get('manufacturer_name', 'サンプルメーカー')
        }

        endpoint['additionalAttributes'] = kwargs.get('additionalAttributes', additionalAttributes)
        if 'cookie' in kwargs:
            endpoint['cookie'] = kwargs.get('cookie', {})

        return endpoint

    def create_payload_endpoint_capability(self, **kwargs):
        # すべての検出応答にはAlexaインターフェースを含める必要があります
        capability = {
            'type': kwargs.get('type', 'AlexaInterface'),
            'interface': kwargs.get('interface', 'Alexa'),
            'version': kwargs.get('version', '3')
        }
        supported = kwargs.get('supported', None)
        if supported:
            capability['properties'] = {}
            capability['properties']['supported'] = supported
            capability['properties']['proactivelyReported'] = kwargs.get('proactively_reported', False)
            capability['properties']['retrievable'] = kwargs.get('retrievable', False)
        return capability

    def get(self, remove_empty=True):

        response = {
            'context': self.context,
            'event': self.event
        }

        if len(self.context_properties) > 0:
            response['context']['properties'] = self.context_properties

        if len(self.payload_endpoints) > 0:
            response['event']['payload']['endpoints'] = self.payload_endpoints

        if remove_empty:
            if len(response['context']) < 1:
                response.pop('context')

        return response

    def set_payload(self, payload):
        self.event['payload'] = payload

    def set_payload_endpoint(self, payload_endpoints):
        self.payload_endpoints = payload_endpoints

    def set_payload_endpoints(self, payload_endpoints):
        if 'endpoints' not in self.event['payload']:
            self.event['payload']['endpoints'] = []

        self.event['payload']['endpoints'] = payload_endpoints

ファイルを保存するには、ファイルの保存を選択します。
関数をデプロイするには、デプロイをクリックします。

Lambda＞関数＞my-smart-home-skillページの上部にある緑色のボックスに、関数が正常に更新されたことを示すメッセージが表示されます。

手順2.4： Lambda関数をテストする

スキルコードを保存したら、Lambda関数を呼び出して、AWS開発者コンソールで結果を確認できます。次のコード例は、Alexa.Discoveryリクエストを送信してエンドポイント機能を報告し、Alexa.PowerControllerリクエストを送信してライトをオンにします。

検出テストを定義する

Lambda＞関数＞my-smart-home-skillページで、テストタブをクリックします。
テストイベントで、新しいイベントを作成を選択します。
イベント名に、「DiscoveryTest」と入力します。
テンプレートのドロップダウンメニューから、Alexa Smart Home Discovery Requestを選択します。
イベントJSONコードエディターで、既存のコードを以下のテストコードに置き換えます。

クリップボードにコピーしました。

{
    "directive": {
        "header": {
            "namespace": "Alexa.Discovery",
            "name": "Discover",
            "payloadVersion": "3",
            "messageId": "1bd5d003-31b9-476f-ad03-71d471922820"
        },
        "payload": {
            "scope": {
                "type": "BearerToken",
                "token": "access-token-from-skill"
            }
        }
    }
}

テストコードを保存するには、保存をクリックします。

電源オンテストを定義する

テストイベントで、新しいイベントを作成を選択します。
イベント名に、「PowerOnTest」と入力します。
テンプレートのドロップダウンメニューから、Alexa Smart Home Control Turn On Requestを選択します。
コードエディターで、既存のコードを以下のテストコードに置き換えます。

クリップボードにコピーしました。

{
  "directive": {
    "header": {
      "namespace": "Alexa.PowerController",
      "name": "TurnOn",
      "messageId": "1bd5d003-31b9-476f-ad03-71d471922820",
      "correlationToken": "1bd5d003-31b9-476f-ad03-71d471922820",
      "payloadVersion": "3"
    },
    "endpoint": {
      "scope": {
        "type": "BearerToken",
        "token": "access-token-from-skill"
      },
      "endpointId": "sample-light-01",
      "cookie": {}
    },
    "payload": {}
  }
}

テストコードを保存するには、変更を保存をクリックします。

AWS開発者コンソールでLambda関数をテストするには

テストを開くには、テストイベントで、イベント名のドロップダウンメニューからDiscoveryTestを選択します。
テストを実行するには、テストイベントで、テストをクリックします。
テストに成功すると、実行結果：成功と表示されます。
ログを表示するには、実行結果ボックス内の詳細を展開します。
ログを閉じるには、xをクリックします。
PowerOnTestについても手順1～4を繰り返します。

手順2.5：リソース名をコピーする

すべてのLambda関数には、関数へのエンドポイントを定義するAmazonリソースネーム（ARN）があります。AlexaはARNによってスキルコードにアクセスします。

以下の画像は、Lambdaコンソールに表示されるサンプルARNを示しています。

AWS開発者コンソールでLambda関数のARNをコピーするには

Lambda＞関数＞my-smart-home-skillページの上部にあるARNのコピーをクリックします。
Windowsのメモ帳やMacのテキストエディットなど、参照しやすい場所にARNを貼り付けて保存します。
この値は、ステップ3：サービスエンドポイントを設定するで使用します。

このページは役に立ちましたか？

フィードバックを送信

最終更新日: 2025 年 11 月 25 日

ステップ2： スキルコードを実装する

AWSコンソールでのスキルコードの実装手順

手順2.1： IAMロールを作成する

手順2.2： Lambda関数を作成する

手順2.3： スキルコードを追加する

手順2.4： Lambda関数をテストする

手順2.5： リソース名をコピーする

ステップ2：スキルコードを実装する

手順2.3：スキルコードを追加する

手順2.5：リソース名をコピーする