[PYTHON] Erstellen Sie mit Amazon Lex einen LINE WORKS-Bot

Dies ist der Artikel am 11. Tag des LINEWORKS Adventskalenders 2019.

Es gibt viele Dienste, die das Erstellen von Chat-Bots vereinfachen, aber dieses Mal habe ich versucht, einen LINE WORKS-Bot mit "Amazon Lex" zu entwickeln, an dem ich mich schon lange interessiert hatte.

Was ist Amazon Lex?

"Amazon Lex" ist ein AWS-Dienst, der eine interaktive Schnittstelle bietet. Es scheint, dass Lex dieselbe Technologie verwendet, die auch in Alexa verwendet wird. Nicht nur die Verarbeitung natürlicher Sprache, sondern auch die Spracherkennung sind enthalten.

https://aws.amazon.com/jp/lex/

Ähnliche Dienste umfassen DialogFlow und Azure Bot Service sowie IBM. Watson Assistant

Dieses Mal habe ich einen Dialogfluss mit Amazon Lex erstellt und einen Bot erstellt, der über LINE WORKS sprechen kann.

!!!Hinweis!!!

__ Ab dem 11.12.19 unterstützt Amazon Lex nur US-Englisch, nicht Japanisch oder die Region Tokio. __ __ Auch diesmal wird es ein Chat-Bot sein, der auf Englisch spricht. (Wann wird es auf Japanisch erhältlich sein ...) Die verwendete Region ist auch Oregon.

Verfassung

lex lineworks (2).png

Eine serverlose Konfiguration mit AWS Lambda.
Erhalten Sie den Rückruf von LINE WORKS über API Gateway. Von dort aus funktioniert es mit Amazon Lex für die interaktive Verarbeitung. --LINE WORKS-Parameter werden im Systems Manager-Parameterspeicher verwaltet. --LINE WORKS-Zugriffstoken werden von Lambda aktualisiert, das regelmäßig ausgeführt wird.

Entwicklungsumgebung

Sprache: Python 3.7.1
Bereitstellen: Verwenden Sie Serverless Framework, um Lambda bereitzustellen

Implementierung

1. Erstellen Sie einen Bot mit Amazon Lex

Dieses Mal habe ich einen Bot mit einem Beispiel gemäß dem offiziellen Tutorial unten erstellt.

Bot-Beispiel: BookTrip - Amazon Lex https://docs.aws.amazon.com/ja_jp/lex/latest/dg/ex-book-trip.html

Einfach gesagt, es ist ein Chatbot, der Autos und Hotels reserviert. Ich habe "Reise buchen" aus dem Beispiel ausgewählt und erstellt.

lex bot book trip

Auf einem solchen Bildschirm können Sie die Absicht und den Dialogfluss festlegen.

Eindruck, dass jeder, der andere Chatbot-Erstellungsdienste verwendet hat, diese sofort verwenden kann. Anfänger hatten das Gefühl, dass es schwierig sein würde, von Grund auf neu zu setzen.

2. Erstellen Sie verschiedene Schlüssel und Bots in der LINE WORKS Developer Console

Melden Sie sich bei der LINE WORKS Developer Console an und erstellen Sie einen Schlüssel oder diesen Bot.

Einzelheiten finden Sie in diesem früheren Artikel.

Lassen Sie uns LINE WORKS Talk Bot in Python implementieren ~ Teil 1: API-Authentifizierung ~ https://qiita.com/mmclsntr/items/1d0f520f1df5dffea24b

3. LINE WORKS Bot App Server Erstellung

Ich habe es mit Lambda konfiguriert und die Laufzeit in Python 3.7 implementiert.

Es gibt zwei Lambda-Funktionen:

__LINE WORKS Access Token Regelmäßiges Update __ --CloudWatch-Ereignis Geplantes Ereignis (einmal jeden halben Tag)
__LINE WORKS Chatbot __

Erhalten Sie Nachrichten von LINE WORKS über API Gateway und arbeiten Sie mit Amazon Lex Bot.

Unten finden Sie einen Beispielcode

`lambda_function.py`


import json
import jwt
import requests
import urllib
import boto3
import os
from datetime import datetime
from base64 import b64encode, b64decode
import hashlib
import hmac

from requests.structures import CaseInsensitiveDict

ssm = boto3.client('ssm')
lex = boto3.client('lex-runtime')

####################################
#Systems Manager-Parameterspeicher#
####################################
def get_parameter(key):
    """
Parameter aus dem SSM-Parameterspeicher abrufen
    """
    response = ssm.get_parameters(
        Names=[
            key
        ],
        WithDecryption=True
    )
    parameters = response["Parameters"]
    if len(parameters) > 0:
        return response['Parameters'][0]["Value"]
    else:
        return ""


def put_parameter(key, value):
    """
Speichern Sie die Parameter im SSM-Parameterspeicher
    """
    response = ssm.put_parameter(
        Name=key,
        Value=value,
        Type='SecureString',
        Overwrite=True
    )


##############
# Amazon Lex #
##############
def post_text_to_lex(text, user_id, bot_name, bot_alias):
    """
Senden Sie Text an Amazon Lex&Erhalten Sie eine Antwort
    """
    response = lex.post_text(
        botName=bot_name,
        botAlias=bot_alias,
        userId=user_id,
        inputText=text
    )

    return response["message"]


##################
# LINE WORKS API #
##################
def get_jwt(server_list_id, server_list_privatekey):
    """
Holen Sie sich das JWT for LINE WORKS-Zugriffstoken
    """
    current_time = datetime.now().timestamp()
    iss = server_list_id
    iat = current_time
    exp = current_time + (60 * 60) #1 Stunde

    secret = server_list_privatekey

    jwstoken = jwt.encode(
        {
            "iss": iss,
            "iat": iat,
            "exp": exp
        }, secret, algorithm="RS256")

    return jwstoken.decode('utf-8')


def get_server_token(api_id, jwttoken):
    """
LINE WORKS Zugriff auf Token-Erfassung
    """
    url = 'https://authapi.worksmobile.com/b/{}/server/token'.format(api_id)

    headers = {
        'Content-Type' : 'application/x-www-form-urlencoded; charset=UTF-8'
    }

    params = {
        "grant_type" : urllib.parse.quote("urn:ietf:params:oauth:grant-type:jwt-bearer"),
        "assertion" : jwttoken
    }

    form_data = params

    r = requests.post(url=url, data=form_data, headers=headers)

    body = json.loads(r.text)
    access_token = body["access_token"]

    return access_token


def validate_request(body, signature, api_id):
    """
LINE WORKS fordern eine Überprüfung an
    """
    #Verwenden Sie die API-ID als privaten Schlüssel
    secretKey = api_id.encode()
    payload = body.encode()

    # HMAC-Codiert mit dem SHA256-Algorithmus
    encoded_body = hmac.new(secretKey, payload, hashlib.sha256).digest()
    #BASE64-Codierung
    encoded_b64_body = b64encode(encoded_body).decode()

    #Vergleich
    return encoded_b64_body == signature


def send_message(content, api_id, botno, consumer_key, access_token, account_id):
    """
Nachricht LINE WORKS senden
    """
    url = 'https://apis.worksmobile.com/{}/message/sendMessage/v2'.format(api_id)

    headers = {
          'Content-Type' : 'application/json;charset=UTF-8',
          'consumerKey' : consumer_key,
          'Authorization' : "Bearer " + access_token
        }

    params = {
            "botNo" : int(botno),
            "accountId" : account_id,
            "content" : content
        }

    form_data = json.dumps(params)

    r = requests.post(url=url, data=form_data, headers=headers)

    if r.status_code == 200:
        return True

    return False

######################
#Lambda-Funktionshandler#
######################
def update_token_handler(event, context):
    """
LINE WORKS Access Token Regelmäßige Aktualisierung der Lambda-Handler-Funktion
    """
    #Rufen Sie die Parameter LINE WORKS aus dem SSM-Parameterspeicher ab
    api_id = get_parameter("lw_api_id")
    server_list_id = get_parameter("lw_server_list_id")
    server_list_privatekey = get_parameter("lw_server_list_private_key").replace("\\n", "\n")
    #Holen Sie sich JWT
    jwttoken = get_jwt(server_list_id, server_list_privatekey)

    #Holen Sie sich das Server-Token
    access_token = get_server_token(api_id, jwttoken)

    #Setzen Sie das Zugriffstoken im Parameterspeicher
    put_parameter("lw_access_token", access_token)

    return


def chat_with_lex_handler(event, content):
    """
LINE WORKS Chatbot Lambda-Handler-Funktion
    """
    botno = os.environ.get("BOTNO")
    lex_bot_name = os.environ.get("LEX_BOT_NAME")
    lex_bot_alias = os.environ.get("LEX_BOT_ALIAS")
    #Rufen Sie die Parameter LINE WORKS aus dem SSM-Parameterspeicher ab
    api_id = get_parameter("lw_api_id")
    consumer_key = get_parameter("lw_server_api_consumer_key")
    access_token = get_parameter("lw_access_token")

    event = CaseInsensitiveDict(event)
    headers = event["headers"]
    body = event["body"]

    #Validierung anfordern
    if not validate_request(body, headers.get("x-works-signature"), api_id):
        #Illegale Anfrage
        return

    #Perth nach Json
    request = json.loads(body)

    #Holen Sie sich senden Benutzer
    account_id = request["source"]["accountId"]

    res_content = {
        "type" : "text",
        "text" : "Only text"
    }

    #Überprüfen Sie den Inhalt der empfangenen Nachricht
    request_type = request["type"]
    ## Message
    if request_type == "message":
        content = request["content"]
        content_type = content["type"]
        ## Text
        if content_type == "text":
            text = content["text"]

            #Funktioniert mit Amazon Lex
            reply_txt = post_text_to_lex(text, account_id.replace("@", "a"), lex_bot_name, lex_bot_alias)

            res_content = {
                "type" : "text",
                "text" : reply_txt
            }

    #Senden
    rst = send_message(res_content, api_id, botno, consumer_key, access_token, account_id)

    res_body = {
        "code": 200,
        "message": "OK"
    }
    response = {
        "statusCode": 200,
        "headers": {
            "Content-Type": "application/json"
        },
        "body": json.dumps(res_body)
    }

    return response

Bitte beachten Sie auch diesen letzten Artikel. Lassen Sie uns LINE WORKS Talk Bot in Python implementieren ~ Teil 2: Chatbot-Implementierung ~ https://qiita.com/mmclsntr/items/28ba6baaf23124a53663

Quellcode

https://github.com/mmclsntr/lineworks-bot-with-amazon-lex

Versuche dich zu bewegen

Sie können (auf Englisch) mit dem von Lex erstellten Chatbot im LINE WORKS-Gespräch wie folgt sprechen. LINE WORKS Lex

Zusammenfassung

Ich konnte den mit Amazon Lex erstellten Chatbot problemlos mit LINE WORKS ausführen. Ich denke, dass einfache Anfragen leicht zu realisieren sind. Ich hoffe, Sie können Japanisch unterstützen. ..

Danach werde ich mit Lex spielen, indem ich verschiedene Dialogeinstellungen optimiere.