[PYTHON] Créons une fonction de chat avec Vue.js + AWS Lambda + dynamo DB [Paramètres AWS]

Depuis que nous avons implémenté la fonction de chat cette fois, nous laisserons un article en mémoire.

Après avoir créé AWS Lambda, je publierai un article sur les paramètres frontaux. Le côté AWS sera créé avec la configuration de ʻAPI Gateway + Lambda + DynamoDB`.

Paramètres de la passerelle API

① Créer une API depuis API Gateway

Depuis API Gateway, appuyez sur «Créer une API» et appuyez sur Nous allons créer l'API WebSocket. 1_API_gateway.png 2_API_gateway.png

② Définir l'API et la formule de sélection d'itinéraire

Définissez le protocole avec le contenu suivant.

Protocole: WebSocket

article Contenu
Nom de l'API vue_chat_test
Formule de sélection d'itinéraire $request.body.action
La description vue_chat_test

3_プロトコル-2.png

③ Définissez la clé racine

Après avoir créé l'API, l'écran passera à l'écran de création de la clé racine. Cette fois, nous définirons chaque clé racine ci-dessous.

Nom de la clé Utilisation
$connect Utilisé lorsque le client démarre la communication WebSocket
$disconnect Utilisé lorsque le client met fin à la communication WebSocket
$default Utilisé lorsqu'il n'y a pas de clé racine correspondante
sendmessage Utilisé lors de l'envoi d'un message
getmessages Utilisé lors de la réception d'un message

Cependant, comme la clé racine ne peut être créée que si la fonction Lambda est créée, Commencez par créer la table dynamoDB et la fonction Lambda.

Créer une table avec dynamoDB

dynamoDB sera créé avec le contenu suivant. La configuration est une hypothèse d'un chat où vous pouvez voir les messages qui vous sont envoyés.

article Contenu Réglage clé
connection_id ID de connexion Clé de partition
user_id Identifiant d'utilisateur
  • messages
article Contenu Réglage clé
user_id ID de connexion Clé de partition
created_at date de création Clé de tri
message message
  • Lors de la création en tant que fonction de chat Je pense que vous avez besoin d'informations telles que l'identifiant de la chambre, qui l'a envoyée à qui et lire les informations, Cette fois, c'est une simple fonction de chat, donc je ne le ferai qu'avec ces informations.

Créer une fonction Lambda

Le runtime crée la fonction Lambda suivante avec Python3.8.

une fonction Contenu Accéder aux paramètres d'autorisation
OnConnect Dans la table de connexion
Enregistrer l'ID de connexion / l'ID utilisateur
dynamoDB
OnDisconnect Supprimer l'enregistrement dans la table de connexion dynamoDB
SendMessage Enregistrer le message dynamoDB,ExecuteAPI
GetMessages Recevoir un message dynamoDB,ExecuteAPI
  • L'autorité d'accès est une fois définie avec l'autorisation d'accès complet
  • OnConnect
import json
import boto3

#Obtenir le tableau de dynamoDB
dynamodb = boto3.resource('dynamodb')
connections = dynamodb.Table('connections')

def lambda_handler(event, context):

    #Obtenez "connectionId, userId"
    connection_id = event.get('requestContext',{}).get('connectionId')
    user_id = event.get('queryStringParameters',{}).get('userId')

    #Ajouter à la table des connexions
    result = connections.put_item(
        Item={
            'connection_id': connection_id,
            'user_id': str(user_id)
        }
    )
    return { 'statusCode': 200,'body': 'ok' }
  • OnDisconnect
import json
import boto3

dynamodb = boto3.resource('dynamodb')
connections = dynamodb.Table('connections')

def lambda_handler(event, context):
    connection_id = event.get('requestContext',{}).get('connectionId')
    result = connections.delete_item(Key={ 'connection_id': connection_id })
    return { 'statusCode': 200, 'body': 'ok' }
  • SendMessage
import json
import boto3
import json
from boto3.dynamodb.conditions import Key, Attr
from datetime import datetime, timedelta, timezone

#Obtenir le tableau de dynamoDB
dynamodb = boto3.resource('dynamodb')
connections = dynamodb.Table('connections')
messages = dynamodb.Table('messages')

#Paramètres de TimeZone
JST = timezone(timedelta(hours=+9), 'JST')

def lambda_handler(event, context):

	#Acquisition de paramètres
    body = json.loads(event["body"])
    user_id = body['user_id']
    message = body['message']
    
    #Date et heure de création
    now = "{0:%Y-%m-%d %H:%M:%S}".format(datetime.now(JST))

    #Enregistrer dans la table des messages
    messages.put_item(
        Item={
            'user_id': user_id,
            'message': message,
            'created_at': now
        }
    )

    #Paramètres d'ApiGatewayManagementApi
    domain_name   = event.get('requestContext',{}).get('domainName')
    stage         = event.get('requestContext',{}).get('stage')
    apigw_management = boto3.client('apigatewaymanagementapi',
                                    endpoint_url=F"https://{domain_name}/{stage}")
                                   
    #Connexion utilisateur de destination_Obtenir l'identifiant
    connection_items = connections.scan(
		ProjectionExpression="connection_id",
        FilterExpression=Attr("user_id").eq(str(user_id))
	).get('Items')    
 
    if len(connection_items) == 0:
	    return { 'statusCode': 200,'body': 'ok' }

    #Obtenir des informations sur le message
    get_message_items = messages.query(
        KeyConditionExpression=Key("user_id").eq(str(user_id)) & Key("created_at").lte(now),
        ScanIndexForward=True
    ).get('Items')

    #Définir le message s'il y a un message, le tableau vide sinon
    content_all = [] if len(get_message_items) == 0 else get_message_items

	#Renvoyer le message à l'utilisateur de destination
    for item in connection_items:
        _ = apigw_management.post_to_connection(ConnectionId=item['connection_id'],
                                                    Data=json.dumps(content_all))

    return { 'statusCode': 200,'body': 'ok' }
  • GetMessages
import boto3
import json
from boto3.dynamodb.conditions import Key, Attr
from datetime import datetime, timedelta, timezone


#définition de table
dynamodb_client = boto3.client('dynamodb')
dynamodb = boto3.resource('dynamodb')
connections = dynamodb.Table('connections')
messages = dynamodb.Table('messages')

#Paramètres de TimeZone
JST = timezone(timedelta(hours=+9), 'JST')

def lambda_handler(event, context):

    #Définir les informations de paramètre sur variable
    body = json.loads(event["body"])
    user_id = body['user_id']
    connection_id = event.get('requestContext',{}).get('connectionId')
    domain_name = event.get('requestContext',{}).get('domainName')
    stage       = event.get('requestContext',{}).get('stage')

    #Vérifiez si l'ID de connexion correspond
    connection_items = connections.query(
        ProjectionExpression="connection_id",
        KeyConditionExpression=Key("connection_id").eq(connection_id),
        FilterExpression=Key('user_id').eq(str(user_id)),
    ).get('Items')

    if len(connection_items) == 0:
        return { 'statusCode': 500,'body': 'something went wrong' }
    
    #Paramètres d'ApiGatewayManagementApi
    apigw_management = boto3.client('apigatewaymanagementapi',
                                    endpoint_url=F"https://{domain_name}/{stage}")
    
    #Date et heure d'acquisition
    now = "{0:%Y-%m-%d %H:%M:%S}".format(datetime.now(JST))

    #Obtenir des informations sur le message
    get_message_items = messages.query(
        KeyConditionExpression=Key("user_id").eq(str(user_id)) & Key("created_at").lte(now),
        ScanIndexForward=True
    ).get('Items')

    #Définir le message s'il y a un message, le tableau vide sinon
    content_all = [] if len(get_message_items) == 0 else get_message_items

    #POSTER un message à la connexion
    _ = apigw_management.post_to_connection(
        ConnectionId=connection_id,
        Data=json.dumps(content_all)
    )
    
    return {
        'statusCode': 200,
        'body': 'ok'
    }

Lier la clé racine et Lambda

Nous lierons le Lambda créé à la clé racine d'API Gateway.

Clé racine Fonction Lambda
$connect OnConnect
$disconnect OnDisconnect
$default OnConnect
sendmessage SendMessage
getmessages GetMessages

4_ルートキーとLambdaの紐付け.png

Déployer l'API WebSocket créée

Une fois la clé racine liée, nous déploierons l'API WebSocket. Cette fois, le nom de la scène est créé avec Test.

5_デプロイ.png

Lorsque le déploiement est terminé, l'URL WebSocket et l'URL de connexion seront émises. Il s'agit de l'URL requise pour la communication avec la réception.

Cela termine les paramètres du côté AWS, et enfin nous ne vérifierons que l'opération.

Fonctionnement confirmé de l'API WebSocket avec wscat

Installez wscat

$ npm install -g wscat

Utilisez wscat pour vérifier l'opération et confirmer que les données sont enregistrées dans dynamoDB.

$ wscat -c [WebSocket URL]?userId=A

Connected (press CTRL+C to quit)
> {"action":"sendmessage","user_id": "A", "message": "Test"}
[{"message": "Test", "user_id": "A", "created_at": "2020-08-29 17:22:43"}]

> {"action":"getmessages", "user_id": "A"}
[{"message": "Test", "user_id": "A", "created_at": "2020-08-29 17:22:43"}]

Cliquez ici pour le statut de dynamoDB!

スクリーンショット 2020-08-29 17.29.17.png スクリーンショット 2020-08-29 17.29.21.png

Résumé

J'ai essayé de créer des paramètres AWS pour la fonction de chat avec Vue.js + AWS Lambda + dynamo DB. Cette fois, je l'ai principalement créé pour fonctionner, donc je pense qu'il n'y a pas beaucoup de traitement en cas d'erreur, et il y a beaucoup d'autres choses à penser afin de l'implémenter réellement.

Ensuite, nous allons créer un écran avant en utilisant Vue.js et communiquer avec l'API.

  • La date et l'heure de publication sont indécises

Si vous avez des suggestions, veuillez commenter!

Recommended Posts