常連

環境
Alexa Skill
AWS Lambda Python3.6


下記を参考にAlexaスキル開発を試しています。

[＜動画＞](https://developer.amazon.com/ja-JP/alexa/alexa-skills-kit/webinars?sc_category=paid&sc_channel=SEM&sc_campaign=SEM-GO^Brand^All^REG^Professional_Developer^Evergreen^JP^Japanese^Text^coding_language&sc_publisher=GO&sc_content=content&sc_detail=379690526073&sc_funnel=convert&sc_country=JP&sc_keyword=alexa%E3%82%B9%E3%82%AD%E3%83%AB%20python&sc_place=&sc_trackingcode=e&sc_segment=sl-linktext&sc_medium=paid%7CSEM%7CSEM-GO^Brand^All^REG^Professional_Developer^Evergreen^JP^Japanese^Text^coding_language%7CGO%7Ccontent%7C379690526073%7Cconvert%7CJP%7Calexa%E3%82%B9%E3%82%AD%E3%83%AB%20python%7C%7Ce%7Csl-linktext&gclid=Cj0KCQiAuefvBRDXARIsAFEOQ9HXXZq2GHX8xAqI8zOftmY5VSJTiWotILZl84aizfb9cvAvxMuUSSkaAppAEALw_wcB)


[＜永続アトリビュートのサンプル＞](https://developer.amazon.com/en-US/docs/alexa/hosted-skills/build-a-skill-end-to-end-using-an-alexa-hosted-skill.html#use-session-persistence-with-python)


ほぼサンプルのままなのですが、以下のエラーが発生します。

### 何をしたいか
コーヒーショップスキルのサンプルで前回の注文内容を取り出すという内容を
Node.jsを参考にみてPythonに読み替えてやっています。
ログを見る限り「persistent_attributes」には想定している内容が入っているのですが
型がおかしいのか上手く永続アトリビュートを保存することが出来ません。

ちょっと途中の段階です。
とりあえず永続アトリビュートを保存までやりたかったのですが完全に躓きました。

### エラー内容(Cloud Watch ログ)
[INFO] 2020-01-02T11:43:56.22Z b0c3b3f8-b9b3-4aaf-ac15-7ea181f14e5d last order is : {'menu': 'コーヒー', 'amount': 1}

[INFO] 2020-01-02T11:43:56.22Z b0c3b3f8-b9b3-4aaf-ac15-7ea181f14e5d attributes is : {'menu': 'コーヒー', 'amount': 1}

[ERROR] 2020-01-02T11:43:56.59Z b0c3b3f8-b9b3-4aaf-ac15-7ea181f14e5d Failed to save attributes to s3 bucket. Exception of type TypeError occurred: expected string or bytes-like object

### 問題のコード
handler_input.attributes_manager.save_persistent_attributes()


### lambda_function.py

```ここに言語を入力
# -*- coding: utf-8 -*-

# This sample demonstrates handling intents from an Alexa skill using the Alexa Skills Kit SDK for Python.
# Please visit https://alexa.design/cookbook for additional examples on implementing slots, dialog management,
# session persistence, api calls, and more.
# This sample is built using the handler classes approach in skill builder.
import logging
import ask_sdk_core.utils as ask_utils

# S3 アダプタ　インポート　START
import os
import boto3
from ask_sdk_s3.adapter import S3Adapter
# CustomSkillBuilderを使用しなければならない
from ask_sdk_core.skill_builder import CustomSkillBuilder
# S3 アダプタ　インポート　END

#2. initialize the persistence adapter to your custom skill builder　BUKET名を設定する
s3_adapter = S3Adapter(bucket_name=os.environ.get('amzn1-ask-skill-自分のBUCKET'))

from ask_sdk_core.skill_builder import SkillBuilder
from ask_sdk_core.dispatch_components import AbstractRequestHandler
from ask_sdk_core.dispatch_components import AbstractExceptionHandler
from ask_sdk_core.handler_input import HandlerInput

from ask_sdk_model import Response

logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)



class LaunchRequestHandler(AbstractRequestHandler):
    """Handler for Skill Launch."""
    def can_handle(self, handler_input):
        # type: (HandlerInput) -> bool

        return ask_utils.is_request_type("LaunchRequest")(handler_input)

    def handle(self, handler_input):
        
        #　前回データ読込
        last_order = handler_input.attributes_manager.session_attributes
        
        menu = "コーヒー"
        amount = "1"
        last_order['menu'] = 'コーヒー'
        last_order['amount'] = 1
        
        handler_input.attributes_manager.persistent_attributes = last_order
        
        logger.info("last order is : %s",last_order)
        logger.info("attributes is : %s",handler_input.attributes_manager.persistent_attributes)
        handler_input.attributes_manager.save_persistent_attributes()
        

        
        
        speak_output = "コーヒーショップへようこそ。前回は" + menu + "を" + amount + "つでしたね。今日は何にしますか？"
        reprompt_output = "今日は何にしますか？"

        return (
            handler_input.response_builder
                .speak(speak_output)
                .ask(reprompt_output)
                .response
        )

------
中略
------

# CustomSkillBuilderを使用しなければならない
sb = CustomSkillBuilder(persistence_adapter=s3_adapter)

sb.add_request_handler(LaunchRequestHandler())
sb.add_request_handler(OrderIntentHandler())
sb.add_request_handler(HelpIntentHandler())
sb.add_request_handler(CancelOrStopIntentHandler())
sb.add_request_handler(SessionEndedRequestHandler())
sb.add_request_handler(IntentReflectorHandler()) # make sure IntentReflectorHandler is last so it doesn't override your custom intent handlers

sb.add_exception_handler(CatchAllExceptionHandler())

lambda_handler = sb.lambda_handler()
```


### requirements.txt
```ここに言語を入力
boto3==1.9.216
ask-sdk-core==1.11.0
ask-sdk-s3-persistence-adapter==1.0.0
ask-sdk-core==1.11.0
boto3==1.9.216
```

ALEXASkill_Pythonでの永続アトリビュートについて

### Pool is closedが直りません

Alexaでデータベースから値を取得し、その値に合わせた挙動を行うSkillを作成しています。
node-mysqlを使用しており、poolでデータベースにアクセスしています。

今現在Skillを連続で実行すると
1回目　正常
2回目　error pool is closed
3回目　正常
4回目　error pool is closed
となってしまいます。

**pool is closedを無くし、毎回正しい動作を行えるようにしたいです。**

pool.endに問題があるのかと思い、pool.endの場所について色々考察してみましたがうまく行かず、相談させていただきました。
node.jsは初学者のため初歩的なところでつまずいていたら大変申し訳ないです。
### 発生している問題・エラーメッセージ

```
  "errorType": "Error",
    "errorMessage": "Pool is closed.",
    "code": "POOL_CLOSED",
    "stack": [
        "Error: Pool is closed.",
        "    at Pool.getConnection (/var/task/node_modules/mysql/lib/Pool.js:25:15)",
        "    at Pool.query (/var/task/node_modules/mysql/lib/Pool.js:202:8)"
```

### 該当のソースコード

```Node.js
const pool = mysql.createPool({
    host     : mysql_host,
    user     : mysql_user,      
    password : mysql_password,
    database : mysql_dbname
    });

function execute(){
    
    return new Promise(function(resolve, reject){
        
        pool.query(sql, (error, result) => {
            if (error) {
                console.log("Supportter select error");
                throw error;
            }
            console.log("Supportter select Success");
        
            console.log(result)
            resolve(result)

        });
  });
}


function excecute2(sid){
    return new Promise(function(resolve, reject){
        
        pool.query(sql,[-], (error, result) => {
            if (error) {
                console.log("Update  error");
                throw error;
            }
            console.log("Update Success");
        

        });
        pool.query(sql,[-], (error, result) => {
            if (error) {
                console.log("Insert error");
                throw error;
            }
            console.log("Insert Success");
            pool.end()
            resolve()
            
        });
        

        });
}

const firsttaskIntent = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'IntentRequest'
            && Alexa.getIntentName(handlerInput.requestEnvelope) === 'firsttaskIntent';
    },
    async handle(handlerInput) {
        var speakOutput =  "msg"
        var messageOutput =  "msg"
        
    //MySQL----------------
    

    var text = await execute()
    console.log(Object.keys(text).length)
    
    
    if(!Object.keys(text).length){
        speakOutput =  "msg"
        messageOutput =  "msg"
        await dbconnection.end();
    }else{
//出力整形
        await excecute2(sid)

        
    }

    
//MySQLend-------------
        
//Display　output**************************************************
...
//addend*********************************************************

        return handlerInput.responseBuilder
            .speak(speakOutput)
            .reprompt(speakOutput)
            .withShouldEndSession(true)
            .getResponse();
    }
};
```

### 試したこと

pool.end()を様々なところに配置しテストしました。→どうしてもpool is closedになる

async/awaitで完全にpool.end()させよう→結局同じ

poolを開けないのでは？→それでは何故1回目は開くの？

といった感じで、大変情けないことになっております。
**何が原因でpool is closedになっているかご教授いただきたいです。**
**可能であれば修正箇所を教えていただきたいです。**


### 補足情報（FW/ツールのバージョンなど）
Lambdaで実行しています。

Node.js Pool is closedが直らない

### 前提・実現したいこと

Amazon Echoで複数のワードごとに、対応するサーボモータを制御したいと考えています。
現在１つのサーボモータを下記のように制御しています。
Initial:90°→"ライトON"→サーボ125°
Initial:90°→"ライトOFF"→サーボ55°
ライティングソフトはArduino、ESP8266を使用、ライブラリはfauxmoESPより引用。

### 該当のソースコード：C++
#include <Arduino.h>
#include <ESP8266WiFi.h>
#include "fauxmoESP.h"
#include <Servo.h>

Servo myservo; 

int servoIni = 90;
int servoState = 0;
int flag = 0;

#define WIFI_SSID "SSID"
#define WIFI_PASS "Password"
 
fauxmoESP fauxmo;
 
// -----------------------------------------------------------------------------
 
#define SERIAL_BAUDRATE     115200
 
#define ID           "ライト"
 
// -----------------------------------------------------------------------------
 
// -----------------------------------------------------------------------------
// Wifi
// -----------------------------------------------------------------------------
 
void wifiSetup() {
    // Set WIFI module to STA mode
    WiFi.mode(WIFI_STA);
 
    // Connect
    Serial.printf("[WIFI] Connecting to %s ", WIFI_SSID);
    WiFi.begin(WIFI_SSID, WIFI_PASS);
 
    // Wait
    while (WiFi.status() != WL_CONNECTED) {
        Serial.print(".");
        delay(100);
    }
    Serial.println();
 
    // Connected!
    Serial.printf("[WIFI] STATION Mode, SSID: %s, IP address: %s\n", WiFi.SSID().c_str(), WiFi.localIP().toString().c_str());
}
 
void setup() {
    // Init serial port and clean garbage
    Serial.begin(SERIAL_BAUDRATE);
    Serial.println();
    Serial.println(); 
    
    // Wifi
    wifiSetup();
 
    // By default, fauxmoESP creates it's own webserver on the defined port
    // The TCP port must be 80 for gen3 devices (default is 1901)
    // This has to be done before the call to enable()
    fauxmo.createServer(true); // not needed, this is the default value
    fauxmo.setPort(80); // This is required for gen3 devices
 
 
    // You have to call enable(true) once you have a WiFi connection
    // You can enable or disable the library at any moment
    // Disabling it will prevent the devices from being discovered and switched
    fauxmo.enable(true);

    // Add virtual devices
    fauxmo.addDevice(ID);
 
    fauxmo.onSetState([](unsigned char device_id, const char * device_name, bool state, unsigned char value) {
        Serial.printf("[MAIN] Device #%d (%s) state: %s value: %d\n", device_id, device_name, state ? "ON" : "OFF", value);
    
        // Checking for device_id is simpler if you are certain about the order they are loaded and it does not change.
        // Otherwise comparing the device_name is safer.
        
        if (strcmp(device_name, ID)==0) {
            if(state){
              flag = 1;
            }else{
              flag = 2;
            }
        }
    });
}

void loop() {
  // fauxmoESP uses an async TCP server but a sync UDP server
    // Therefore, we have to manually poll for UDP packets
    fauxmo.handle();

    if(flag == 1){
      lightOn();
      flag = 0;
    }else if(flag == 2){
      lightOff();
      flag = 0;
    }
}
 
void lightOn() {
  myservo.attach(D8);
  delay(500);
  myservo.write(55);
  delay(500);
  myservo.write(servoIni);
  delay(500);
  myservo.detach();
  Serial.print("Switch turn on ...");
}
 
void lightOff() {
  myservo.attach(D8);
  delay(500);
  myservo.write(125);
  delay(500);
  myservo.write(servoIni);
  delay(500);
  myservo.detach();
  Serial.print("Switch turn off ...");
}

### 発生している問題
Alexaへの指定ワードを追加し（例：リビング、キッチンなど）、
対応するサーボモータの動作に関連付けできたらと考えています。
1台のESP8266もしくはESP32でAlexaより数通りの信号を受信、複数のサーボモータを制御、
という意味です。

### 試したこと
IDを複数作成し、対応するピンを指定したのですが、
スクリプト自体がRedefineによりエラー、もしくはコンパイルできても適正に信号が送られず、
サーボモータが動作しません。

ご教示のほど、何卒宜しくお願い致します。

アレクサからの複数サーボモータの制御について

現在Alexa Developer Consoleを使用して、「ai相談」と呼ばれるAlexaスキルを作成し、GPT-3.5を使用して質問に答えるようにしたいと考えています。
しかし、「ai相談」を起動して、Alexaスキルに質問すると、「スキルがリクエストに正しく応答できませんでした」という返答しか得られません。
そこで、どのように問題を解決できるかについてアドバイスをいただけないでしょうか。

### 実現したいこと

手持ちのAlexa機器から、「ai相談」と呼ばれるAlexaスキルを起動し、GPT-3.5を使用して質問に答えるようにしたいと考えています。
なお開発したalexa skillは一般公開しません。

### 前提

ChatGPTが面白いので、自分だけがPCなど上でいじっているだけではなく、家族の会話の中で気軽に呼び出したくなってきました。
そこで、手持ちのAlexa機器からGPT-3.5を呼び出す方法はないかと調べていたところ、allforbigfireさんの[AlexaにGPT-3.5を接続して、回答を比べた。](https://zenn.dev/allforbigfire/articles/ca5d4d38023471)記事がズバリだと感じたので、その記事を参考に自作のAlexa Skill「ai相談」をnode.jsで作っています。
しかし以下のところから進まなくなりましたのでアドバイスをいただきたいです。

```
入力欄に、「(設定したAlexaスキルの名称)を開いて」を入力します。

(画像)

こんな感じの返答が繰り返しできるはずです。
Alexa単独ではこんな会話は出来ないので面白いですね。
```

Alexa Developer ConsoleからCloud Watch Logsを開くのですが、それらしいエラーログも見つからないので、どこから対処すればよいのかわからず悩んでいます。

### 発生している問題・エラーメッセージ

#### テストでの挙動

```
私：ai相談を開いて
alexa：ai相談起動したで。なんでも聞いてな。
私：簡単にできる晩御飯のおすすめを教えてください
alexa：スキルがリクエストに正しく応答できませんでした
```

#### CloudWatchのログ

```
INIT_START Runtime Version: nodejs:12.v28	Runtime Version ARN: arn:aws:lambda:us-east-1::runtime:77abd29a376492953263fdbbd771e2b863be367d591311a62a99db79d326dc26
START RequestId: 395a1375-77ef-49b6-9171-efe58b771320 Version: 4
END RequestId: 395a1375-77ef-49b6-9171-efe58b771320
REPORT RequestId: 395a1375-77ef-49b6-9171-efe58b771320	Duration: 3.26 ms	Billed Duration: 4 ms	Memory Size: 512 MB	Max Memory Used: 62 MB	Init Duration: 208.02 ms	
```

### 該当のソースコード

#### package.json

```json
{
  "name": "hello-world",
  "version": "1.2.0",
  "description": "alexa utility for quickly building skills",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "Amazon Alexa",
  "license": "Apache License",
  "dependencies": {
    "ask-sdk-core": "^2.7.0",
    "ask-sdk-model": "^1.19.0",
    "aws-sdk": "^2.326.0",
    "axios": "^0.16.2"
  }
}
```

#### index.js

※Authorization部分はdummy値です

```javascript
/* *
 * This sample demonstrates handling intents from an Alexa skill using the Alexa Skills Kit SDK (v2).
 * Please visit https://alexa.design/cookbook for additional examples on implementing slots, dialog management,
 * session persistence, api calls, and more.
 * */
const Alexa = require('ask-sdk-core');

const axios = require('axios');
const title = 'ai相談';

const LaunchRequestHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'LaunchRequest';
    },
    handle(handlerInput) {
        const speakOutput = 'ai相談や。なんでも聞いて。';

        return handlerInput.responseBuilder
            .speak(speakOutput)
            .withSimpleCard(
                title, 
                speakOutput)
            .reprompt(speakOutput)
            .getResponse();
    }
};


const HelloWorldIntentHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'IntentRequest'
            && Alexa.getIntentName(handlerInput.requestEnvelope) === 'HelloWorldIntent';
    },
    async handle(handlerInput) {
        const speechText = handlerInput.requestEnvelope.request.intent.slots.message.value;
        const speechText_add_conditions = '以下条件で答えよ（条件）・京都弁喋る若い女性として答る・文字数最大600文字程・小学生にもわかりやすく・重要キーワードを残さない（質問）'+speechText;
        console.log('speechText:'+speechText);

// ここでChatGPTに繋げる
        const response =  await getChatGptResponse(speechText);
        console.log('response:'+response);

        return handlerInput.responseBuilder
            .speak(response)
            .withSimpleCard(
                title,
                response)            
            .reprompt(response)
            .getResponse();
    }
};

async function getChatGptResponse(input) {
  const endpoint = 'https://api.openai.com/v1/completions';
  const headers = {
    'Content-Type': 'application/json',
    'Authorization': `Bearer dummy`,
  };
  const data = {
    prompt: input,
    max_tokens: 2000,
    model: "text-davinci-003"
  };

  try {
    const response = await axios.post(endpoint, data, { headers });
    return response.data.choices[0].text;
  } catch (err) {
    console.error(err);
    return null;
  }
}

const HelpIntentHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'IntentRequest'
            && Alexa.getIntentName(handlerInput.requestEnvelope) === 'AMAZON.HelpIntent';
    },
    handle(handlerInput) {
        const speakOutput = 'You can say hello to me! How can I help?';

        return handlerInput.responseBuilder
            .speak(speakOutput)
            .reprompt(speakOutput)
            .getResponse();
    }
};

const CancelAndStopIntentHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'IntentRequest'
            && (Alexa.getIntentName(handlerInput.requestEnvelope) === 'AMAZON.CancelIntent'
                || Alexa.getIntentName(handlerInput.requestEnvelope) === 'AMAZON.StopIntent');
    },
    handle(handlerInput) {
        const speakOutput = 'Goodbye!';

        return handlerInput.responseBuilder
            .speak(speakOutput)
            .getResponse();
    }
};
/* *
 * FallbackIntent triggers when a customer says something that doesn’t map to any intents in your skill
 * It must also be defined in the language model (if the locale supports it)
 * This handler can be safely added but will be ingnored in locales that do not support it yet 
 * */
const FallbackIntentHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'IntentRequest'
            && Alexa.getIntentName(handlerInput.requestEnvelope) === 'AMAZON.FallbackIntent';
    },
    handle(handlerInput) {
        const speakOutput = 'Sorry, I don\'t know about that. Please try again.';

        return handlerInput.responseBuilder
            .speak(speakOutput)
            .reprompt(speakOutput)
            .getResponse();
    }
};
/* *
 * SessionEndedRequest notifies that a session was ended. This handler will be triggered when a currently open 
 * session is closed for one of the following reasons: 1) The user says "exit" or "quit". 2) The user does not 
 * respond or says something that does not match an intent defined in your voice model. 3) An error occurs 
 * */
const SessionEndedRequestHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'SessionEndedRequest';
    },
    handle(handlerInput) {
        console.log(`~~~~ Session ended: ${JSON.stringify(handlerInput.requestEnvelope)}`);
        // Any cleanup logic goes here.
        return handlerInput.responseBuilder.getResponse(); // notice we send an empty response
    }
};
/* *
 * The intent reflector is used for interaction model testing and debugging.
 * It will simply repeat the intent the user said. You can create custom handlers for your intents 
 * by defining them above, then also adding them to the request handler chain below 
 * */
const IntentReflectorHandler = {
    canHandle(handlerInput) {
        return Alexa.getRequestType(handlerInput.requestEnvelope) === 'IntentRequest';
    },
    handle(handlerInput) {
        const intentName = Alexa.getIntentName(handlerInput.requestEnvelope);
        const speakOutput = `You just triggered ${intentName}`;

        return handlerInput.responseBuilder
            .speak(speakOutput)
            //.reprompt('add a reprompt if you want to keep the session open for the user to respond')
            .getResponse();
    }
};
/**
 * Generic error handling to capture any syntax or routing errors. If you receive an error
 * stating the request handler chain is not found, you have not implemented a handler for
 * the intent being invoked or included it in the skill builder below 
 * */
const ErrorHandler = {
    canHandle() {
        return true;
    },
    handle(handlerInput, error) {
        const speakOutput = 'Sorry, I had trouble doing what you asked. Please try again.';
        console.log(`~~~~ Error handled: ${JSON.stringify(error)}`);

        return handlerInput.responseBuilder
            .speak(speakOutput)
            .reprompt(speakOutput)
            .getResponse();
    }
};

/**
 * This handler acts as the entry point for your skill, routing all request and response
 * payloads to the handlers above. Make sure any new handlers or interceptors you've
 * defined are included below. The order matters - they're processed top to bottom 
 * */
exports.handler = Alexa.SkillBuilders.custom()
    .addRequestHandlers(
        LaunchRequestHandler,
        HelloWorldIntentHandler,
        HelpIntentHandler,
        CancelAndStopIntentHandler,
        FallbackIntentHandler,
        SessionEndedRequestHandler,
        IntentReflectorHandler)
    .addErrorHandlers(
        ErrorHandler)
    .withCustomUserAgent('sample/hello-world/v1.2')
    .lambda();
```

### 試したこと

ちょっとキャラ付けをして喋ってほしいなと思って、const speechText_add_conditions を追加したのがまずかったのかと思い、ここをallforbigfireさんのオリジナルに戻したりもしたのですが、改善しませんでした。
なお、APIキー自身は以下のcurl文で動作し、使えるのを確認しています。

```
curl https://api.openai.com/v1/completions \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer dummy' \
  -d '{
  "model": "text-davinci-003",
  "max_tokens": 3500,
  "prompt": "以下条件で答えよ（条件）・京都弁喋る若いしっかり者の女性で返答・文字数最大600文字程・小学生にもわかりやすく・重要キーワードを残さない・末尾にしらんけど（質問）簡単にできる晩御飯のおすすめを教えてください"
  }'
```

以上よろしくお願いいたします。


Alexa Developer ConsoleのテストからGPT-3.5を使用したいが、「スキルがリクエストに正しく応答できませんでした」と返されてしまう

### 前提・実現したいこと

Alexaのスキル開発を行なっています。
AWSで所持している内容（アクセストークンや指示内容）をFirebase内にあるFunctionへGET送信したいのですが
以下のエラーメッセージが発生しました。

### 発生している問題・エラーメッセージ
Alexaシミュレータでのテスト時に発生
```
スキルからの応答に問題があります
```

### 該当のソースコード
以下はAWSに記載しているNode.jsです（該当箇所を一部抜粋）
```ここに言語名を入力

   'TestIntent': function () {
	 
    // askEventIntent
    'use strict';
	var self = this;
	var accessToken = this.event.session.user.accessToken;
    var url = 'https://*****.cloudfunctions.net/hello?name=' + 'abc' + '&token=' + accessToken;
	
    https.get(url, function(res) {
  		console.log('応答を得る')
  		res.setEncoding('utf8');
  	res.on('data', function(str) {
    	console.log(str);
  	});
	});

req.setTimeout(1000);

req.on('timeout', function() {
  console.log('request timed out');
  req.abort()
});

req.on('error', function(err) {
  console.log("Error: " + err.code + ", " + err.message);
});

   }


```

### 受信側のソースコード
念のため、受信側のFirebaseのソースコードも記載します。
```ここに言語名を入力
const functions = require('firebase-functions');

exports.hello = functions.https.onRequest((request, response) => {
  if (request.query.name !== undefined) {
    let param = {
	name:request.query.name,
	token:request.query.token
	}

    response.status(200).send("action: " + param.name + " AccessToken " + param.token)
  } else {
    response.status(200).send("Hello World")
  }
})
```

### 試したこと

Firebaseへ、[Advanced REST client](https://chrome.google.com/webstore/detail/advanced-rest-client/hgmloofddffdnphfgcellkdfbfbjeloo?hl=ja)を用いてGET送信すると無事に処理されました。

AWS（Lambda）からFirebaseへのGETリクエストを送信

以下の記事を参考に、LINEログインとMessaging APIを使って、AlexaスキルからLINE botに通知するスキルを開発しています。
記事：[https://qiita.com/imajoriri/items/0e975b15b9023cafce24](https://qiita.com/imajoriri/items/0e975b15b9023cafce24)

外部モジュールを使うので、ローカルにインストールしzipで圧縮しLambdaにアップロードしたのですが、以下のエラーがでました。


```
Unable to import module 'index': Error
at Function.Module._resolveFilename (module.js:547:15)
at Function.Module._load (module.js:474:25)
at Module.require (module.js:596:17)
at require (internal/module.js:11:18)
at Object.<anonymous> (/var/task/index.js:4:15)
at Module._compile (module.js:652:30)
at Object.Module._extensions..js (module.js:663:10)
at Module.load (module.js:565:32)
at tryModuleLoad (module.js:505:12)
at Function.Module._load (module.js:497:3)
```

このエラーはLambdaの設定で、ハンドラの名前がindex.handlerになってないこと(index.jsの場合)が原因らしいのですが、index.handlerに設定してあります。

このエラーの原因が分かる方は教えてください。

また、zipファイルの内部は以下になります。
index.js
node_modules

以下、index.jsのコードとAlexa Developer Consoleでテストした時のレスポンスです。
```javascript
/* eslint-disable  func-names */
/* eslint-disable  no-console */

const Alexa = require('ask-sdk');
const rp = require('request-promise');
const line = require('@line/bot-sdk');

const client = new line.Client({
  // Lambdaの環境変数よりMessagingAPIのチャネルアクセストークンを取得
  channelAccessToken:  process.env["channelAccessToken"]
});

const LaunchRequestHandler = {
  canHandle(handlerInput) {
    return handlerInput.requestEnvelope.request.type === 'LaunchRequest';
  },
  async handle(handlerInput) {
    // Userごとのアクセストークン
    const accessToken = handlerInput.requestEnvelope.session.user.accessToken;
    console.log(accessToken);

    var options = {
      method: 'GET',
      uri: 'https://api.line.me/v2/profile',
      headers: {
        'Authorization': `Bearer ${accessToken}`
      }
    };
    // アクセストークンより、LINEのUser情報を取得
    var lineData = JSON.parse(await rp(options));

    const message = {
      type: 'text',
      text: 'スキルが起動されました。'
    };

    const userId = lineData.userId;

    // botに通知を送信
    await client.pushMessage(userId, message);

    var msg = 'Botにメッセージが送信されました';

    return handlerInput.responseBuilder
      .speak(msg)
      .reprompt(msg)
      .getResponse();
  }
};

// const GetNewFactHandler = {
//   canHandle(handlerInput) {
//     const request = handlerInput.requestEnvelope.request;
//     return request.type === 'LaunchRequest'
//       || (request.type === 'IntentRequest'
//         && request.intent.name === 'GetNewFactIntent');
//   },
//   handle(handlerInput) {
//     const factArr = data;
//     const factIndex = Math.floor(Math.random() * factArr.length);
//     const randomFact = factArr[factIndex];
//     const speechOutput = GET_FACT_MESSAGE + randomFact;

//     return handlerInput.responseBuilder
//       .speak(speechOutput)
//       .withSimpleCard(SKILL_NAME, randomFact)
//       .getResponse();
//   },
// };

const HelpHandler = {
  canHandle(handlerInput) {
    const request = handlerInput.requestEnvelope.request;
    return request.type === 'IntentRequest'
      && request.intent.name === 'AMAZON.HelpIntent';
  },
  handle(handlerInput) {
    return handlerInput.responseBuilder
      .speak(HELP_MESSAGE)
      .reprompt(HELP_REPROMPT)
      .getResponse();
  },
};

const ExitHandler = {
  canHandle(handlerInput) {
    const request = handlerInput.requestEnvelope.request;
    return request.type === 'IntentRequest'
      && (request.intent.name === 'AMAZON.CancelIntent'
        || request.intent.name === 'AMAZON.StopIntent');
  },
  handle(handlerInput) {
    return handlerInput.responseBuilder
      .speak(STOP_MESSAGE)
      .getResponse();
  },
};

const SessionEndedRequestHandler = {
  canHandle(handlerInput) {
    const request = handlerInput.requestEnvelope.request;
    return request.type === 'SessionEndedRequest';
  },
  handle(handlerInput) {
    console.log(`Session ended with reason: ${handlerInput.requestEnvelope.request.reason}`);

    return handlerInput.responseBuilder.getResponse();
  },
};

const ErrorHandler = {
  canHandle() {
    return true;
  },
  handle(handlerInput, error) {
    console.log(`Error handled: ${error.message}`);

    return handlerInput.responseBuilder
      .speak('Sorry, an error occurred.')
      .reprompt('Sorry, an error occurred.')
      .getResponse();
  },
};

const SKILL_NAME = 'Space Facts';
const GET_FACT_MESSAGE = 'Here\'s your fact: ';
const HELP_MESSAGE = 'You can say tell me a space fact, or, you can say exit... What can I help you with?';
const HELP_REPROMPT = 'What can I help you with?';
const STOP_MESSAGE = 'Goodbye!';

const data = [
  'A year on Mercury is just 88 days long.',
  'Despite being farther from the Sun, Venus experiences higher temperatures than Mercury.',
  'Venus rotates counter-clockwise, possibly because of a collision in the past with an asteroid.',
  'On Mars, the Sun appears about half the size as it does on Earth.',
  'Earth is the only planet not named after a god.',
  'Jupiter has the shortest day of all the planets.',
  'The Milky Way galaxy will collide with the Andromeda Galaxy in about 5 billion years.',
  'The Sun contains 99.86% of the mass in the Solar System.',
  'The Sun is an almost perfect sphere.',
  'A total solar eclipse can happen once every 1 to 2 years. This makes them a rare event.',
  'Saturn radiates two and a half times more energy into space than it receives from the sun.',
  'The temperature inside the Sun can reach 15 million degrees Celsius.',
  'The Moon is moving approximately 3.8 cm away from our planet every year.',
];

const skillBuilder = Alexa.SkillBuilders.standard();

exports.handler = skillBuilder
  .addRequestHandlers(
    LaunchRequestHandler,
    // GetNewFactHandler,
    HelpHandler,
    ExitHandler,
    SessionEndedRequestHandler
  )
  .addErrorHandlers(ErrorHandler)
  .lambda();
```

レスポンス
```
{
	"version": "1.0",
	"session": {
		"new": false,
		"sessionId": "amzn1.echo-api.session.c6c70564-b3a6-483b-9fb1-3a5c81bacccc",
		"application": {
			"applicationId": "amzn1.ask.skill.0069cc67-8e5a-4305-9f9d-5c3d433d96d6"
		},
		"user": {
			"userId": "個人情報なので省略",
			"accessToken": "個人情報なので省略"
		}
	},
	"context": {
		"System": {
			"application": {
				"applicationId": "amzn1.ask.skill.0069cc67-8e5a-4305-9f9d-5c3d433d96d6"
			},
			"user": {
				"userId": "個人情報なので省略",
				"accessToken": "個人情報なので省略"
			},
			"device": {
				"deviceId": "個人情報なので省略",
				"supportedInterfaces": {}
			},
			"apiEndpoint": "https://api.fe.amazonalexa.com",
			"apiAccessToken": "個人情報なので省略"
		},
		"Viewport": {
			"experiences": [
				{
					"arcMinuteWidth": 246,
					"arcMinuteHeight": 144,
					"canRotate": false,
					"canResize": false
				}
			],
			"shape": "RECTANGLE",
			"pixelWidth": 1024,
			"pixelHeight": 600,
			"dpi": 160,
			"currentPixelWidth": 1024,
			"currentPixelHeight": 600,
			"touch": [
				"SINGLE"
			],
			"video": {
				"codecs": [
					"H_264_42",
					"H_264_41"
				]
			}
		}
	},
	"request": {
		"type": "SessionEndedRequest",
		"requestId": "amzn1.echo-api.request.e911134b-5bf9-416e-b594-33fe204658eb",
		"timestamp": "2019-09-13T00:21:58Z",
		"locale": "ja-JP",
		"reason": "ERROR",
		"error": {
			"type": "INVALID_RESPONSE",
			"message": "An exception occurred while dispatching the request to the skill."
		}
	}
}
```

Lambdaでのエラー、「Unable to import module 'index'」の原因が分からない

こんにちは。

Amazon Alexaでスキルを作成しています。作成したスキルを公開しないで自分だけ使いたいのですが、可能でしょうか？一旦Amazonの審査通して、開発者モードにすれば良さそうなのですが、審査せずにできる方法があればよいかなと思います。よろしくお願いします。

Amazon Echoでスキルをプライベートに公開したい

解決しました解決しました解決しました解決しました解決しました解決しました解決しました解決しました解決しました解決しました解決しました解決しました解決しました解決しました解決しました解決しました解決しました解決しました解決しました解決しました解決しました解決しました解決しました解決しました