introduction

Décembre était tôt et nous avons atteint la phase intermédiaire. Personnellement, je me sens très heureux car ce jour est mon anniversaire. J'ai écrit cet article avec ce sentiment. Récemment, j'ai touché Serverless Framework et AWS, alors j'ai essayé de le résumer à ma manière. Les services que j'ai utilisés sont Lambda et S3, SQS et API Gateway, j'ai donc écrit à ce sujet.

Le code utilisé cette fois-ci se trouve ici.

De plus, j'ai fait référence aux articles suivants lors de la création de cet article. Complètement sans serveur ①: Introduction à Serverless Framework L'histoire de la création d'un système de vote ultra-simple avec Serverless Framework et S3 [J'ai essayé d'utiliser Lambda avec Python 3.6 avec Serverless Framework] (https://dev.classmethod.jp/cloud/aws/serverless-framework-with-python-3-6/) Résumé de l'utilisation du Framework sans serveur

Préparation / environnement

Nécessite un environnement Node.js et Python. Vous aurez également besoin d'un compte AWS. Node.js est requis pour utiliser Serverless Framework et Python est requis pour utiliser AWS CLI.

1. Installez Serverless

Installez avec npm.

$ npm install -g serverless

＄ sls -v
Framework Core: 1.54.0
Plugin: 3.1.2
SDK: 2.1.2
Components Core: 1.1.1
Components CLI: 1.4.0

Si cela s'affiche, l'installation est terminée.

2. Créez un utilisateur IAM et définissez les informations d'identification AWS

Vous devez créer un IAM pour utiliser AWS avec Serverless Framework.

Créer un utilisateur IAM

Vous pouvez le créer en cliquant sur Créer un utilisateur à partir d'un utilisateur dans le tableau de bord IAM. En gros, tout ce que vous avez à faire est de vérifier l'accès par programmation et de lui donner les autorisations dont vous avez besoin pour le créer cette fois. Notez également que la clé d'informations d'identification AWS ne peut être obtenue qu'ici.

Paramètres des informations d'identification AWS

Vous devez installer l'AWS CLI afin de configurer les paramètres des informations d'identification AWS. Vous pouvez l'installer avec la commande suivante.

$ pip install aws-sdk

$ aws --version
aws-cli/1.16.276 Python/3.7.3 Darwin/18.7.0 botocore/1.13.12

Si cela s'affiche, l'installation est terminée. Définissez les informations d'identification AWS comme suit.

$ aws configure
AWS Access Key ID [None]:ID de clé d'accès IAM créé
AWS Secret Access Key [None]:Clé d'accès secrète IAM créée
Default region name [None]: ap-northeast-1
Default output format [None]: ENTER

Citation: Complètement sans serveur ①: Introduction à Serverless Framework

Vous êtes maintenant prêt à utiliser le Framework sans serveur.

3. Hello World avec Serverless Framework

Commençons par créer un projet Serverless. Vous pouvez le créer en tapant la commande suivante.

$ sls create -t aws-python3 -p Projet Hogehoge

Si ce qui suit est affiché, cela réussit.

Serverless: Generating boilerplate...
Serverless: Generating boilerplate in "/..."
 _______                             __
|   _   .-----.----.--.--.-----.----|  .-----.-----.-----.
|   |___|  -__|   _|  |  |  -__|   _|  |  -__|__ --|__ --|
|____   |_____|__|  \___/|_____|__| |__|_____|_____|_____|
|   |   |             The Serverless Application Framework
|       |                           serverless.com, v1.54.0
 -------'

Serverless: Successfully generated boilerplate for template: "aws-python3"

Ensuite, modifiez handler.py``` dans le répertoire du nom du projet comme suit.

`handler.py`


import json

def hello(event, context):
    body = {
        "message": "Hello, world",
    }

    response = {
        "statusCode": 200,
        "body": json.dumps(body)
    }

    return response

Définissez également la région de destination du déploiement sur Tokyo.

`serverless.yml`


service:Hogehoge

provider:
  name: aws
  runtime: python3.7
  region: ap-northeast-1 #Déployer dans la région de Tokyo

functions:
  hello:
    handler: handler.hello

Puis déployez.

$ sls deploy

Je le ferai.

＄ sls invoke -f hello

Si ce qui suit est affiché, cela réussit.

{
    "statusCode": 200,
    "body": "{\"message\": \"Hello, world\"}"
}

En outre, une fonction est déployée sur le tableau de bord AWS Lambda, vous pouvez donc essayer de l'exécuter à partir de là.

4. Lancez Lambda depuis API Gate Way

Tout d'abord, exécutons la fonction hello déployée précédemment à l'aide d'API Gateway. Modifiez serverless.yml``` comme suit.

`serverless.yml`


service:Hogehoge

provider:
 ...

functions:
  hello:
    handler: handler.hello
    #Ajouter à partir d'ici
    events:
      - http:
          path: hello
          method: get
          cors: true

Citation: https://serverless.com/framework/docs/providers/aws/events/apigateway/

Si vous faites `` sls deployaprès cela, vous obtiendrezendpoints``` comme indiqué ci-dessous.

Service Information
...
endpoints:
  GET - https://hogehoge.amazonaws.com/dev/hello
functions:
  hello: hogehoge-dev-hello
layers:
  None

Si vous appuyez sur cette API avec une commande curl, etc., Hello World sera affiché.

5. Enregistrez le fichier sur S3 et lisez-le

Créer une fonction pour enregistrer un fichier dans S3

Créez un nouveau `` sthreeput.py '' et écrivez comme suit. Ici, nous allons créer une fonction qui enregistre un fichier texte contenant 10 nombres aléatoires jusqu'à 100 avec le nom de la date et de l'heure.

`sthreeput.py`


import boto3 #AWS SDK pour Python

import datetime
import random

s3 = boto3.resource('s3')
bucketName = "hogehogebucket" #Le nom du compartiment S3 que vous avez choisi

def index(event, context):
    dt = datetime.datetime.now()
    text = ""
    for i in range(10):
        num = str(random.randint(0, 100))
        text += num + " "

    key = "{0:%Y-%m-%d-%H-%M-%S}.txt".format(dt) #Devenir le nom du fichier à enregistrer

    obj = s3.Object(bucketName, key) 
    obj.put(Body=text.encode())

    return {
        "statusCode": 200,
        "body": text
    }

paramètres serverless.yml

Créez un compartiment S3 pour stocker les fichiers. Il décrit également une fonction pour ajouter des fichiers à S3. Veuillez noter que le nom de compartiment de S3 ne peut pas être utilisé s'il existe déjà (même s'il n'est pas le vôtre).

`serverless.yml`



functions:
  hello:
  ....
  #Nom de la fonction
  sthree-put:
    handler: sthreeput.index #sthreeput.Appelle la fonction d'index de py

resources:
  Resources:
    SthreeBucket: #Créer un compartiment pour S3
      Type: AWS::S3::Bucket
      Properties:
        BucketName : "hogehogebucket" #Nom du compartiment S3 (ne peut pas être nommé déjà)

Maintenant, sls deploy``` et exécutons la fonction. Si tout se passe bien, le bucket que vous avez créé contiendra le fichier.

Afficher le fichier déclenché par le fichier en cours d'enregistrement dans S3

Créez un nouveau `` sthreereceive.py '' comme suit.

`sthreereceive.py`


import boto3

s3 = boto3.client('s3')

def index(event, context):
    bucket = event["Records"][0]["s3"]["bucket"]["name"] #Nom du godet
    key = event["Records"][0]["s3"]["object"]["key"] #Le nom du fichier enregistré
    response = s3.get_object(Bucket=bucket, Key=key) #Récupérez les objets dans le seau
    body = response['Body'].read().decode("utf-8") #Obtenez les informations dans le fichier et utf-Décoder à 8
    print(body)
    return body

Lorsque la fonction Lambda est démarrée en étant accrochée à S3, le JSON suivant est passé au premier événement d'argument.

{
  "Records": [
    {
      "eventVersion": "2.0",
      "eventSource": "aws:s3",
      "awsRegion": "ap-northeast-1",
      "eventTime": "1970-01-01T00:00:00.000Z",
      "eventName": "ObjectCreated:Put",
      "userIdentity": {
        "principalId": "EXAMPLE"
      },
      "requestParameters": {
        "sourceIPAddress": "127.0.0.1"
      },
      "responseElements": {
        "x-amz-request-id": "EXAMPLE123456789",
        "x-amz-id-2": "EXAMPLE123/5678abcdefghijklambdaisawesome/mnopqrstuvwxyzABCDEFGH"
      },
      "s3": {
        "s3SchemaVersion": "1.0",
        "configurationId": "testConfigRule",
        "bucket": {
          "name": "example-bucket",
          "ownerIdentity": {
            "principalId": "EXAMPLE"
          },
          "arn": "arn:aws:s3:::example-bucket"
        },
        "object": {
          "key": "test/key", 
          "size": 1024,
          "eTag": "0123456789abcdef0123456789abcdef",
          "sequencer": "0A1B2C3D4E5F678901"
        }
      }
    }
  ]
}

À partir de ces informations, nous obtenons le nom du compartiment S3 et la clé qui est le nom du fichier.

paramètres serverless.yml

Réglez la fonction et l'événement de S3.

`serverless.yml`


...
functions:
  sthree-put:
    handler: sthreeput.index #sthreeput.Appelle la fonction d'index de py

  sthree-receive:
    handler: sthreereceive.index
    events:
    - s3:
        bucket: "sthreebucket-hogehoge" #Nom du godet
        event: s3:ObjectCreated:* #Commencer une fois fait sur S3
        existing: true #Puisque je crée un compartiment pour S3, je vais attacher ceci

Sans le dernier existing: ture, un bucket sera créé et vous ne pourrez pas le déployer si vous avez déjà un bucket du même nom. Nous avons défini cette option car nous avons créé le bucket plus tôt. Vous pouvez déployer sans la dernière option en effaçant la partie Resources de serverless.yml et en faisant `` sls remove``` pour le nettoyer.

Maintenant, si vous faites `` sls deploy '' et démarrez la fonction sthreeput, vous pouvez voir que le fichier est enregistré dans le bucket et que la fonction sthreereceive est démarrée en surveillant le tableau de bord Lambda.

De plus, cette fois, j'ai vérifié le fichier en utilisant le fait qu'il a été enregistré dans S3 comme déclencheur, mais vous pouvez également vérifier le fichier en spécifiant le nom du compartiment et la clé du fichier que vous souhaitez vérifier.

6. Envoyez un message à SQS et recevez le message

Créer une fonction pour envoyer un message à SQS

Décrivez récemment `` sendmessage.py '' comme suit.

`sendmessage.py`


import boto3
import random
import json

sqs = boto3.resource('sqs')
queueName = "hogehoge-queue"


def index(event, context):
    queue = sqs.get_queue_by_name(QueueName=queueName)  #Obtenir la file d'attente

    message = ""  #Message à envoyer

    for i in range(10):
        num = str(random.randint(0, 100))
        message += num + " "
        
    print(message)

    queue.send_message(MessageBody=json.dumps({ "message": message })) #Envoyer le message
    
    return message

paramètres serverless.yml

Créez une file d'attente pour envoyer des messages. Contrairement au compartiment S3, le nom de la file d'attente SQS peut être le même que celui d'un autre compte.

`serverless.yml`


provider:
  ...
  iamRoleStatements:
  - Effect: "Allow"
    Action:
    - "s3:PutObject"
    - "s3:GetObject"
    - "s3:ListBucket"
    - "sqs:CreateQueue"
    - "sqs:DeleteQueue"
    - "sqs:SendMessage"
    - "sqs:GetQueueUrl"
    Resource: "*"
...
functions:
  sthree-put:
  ...
  sendmessage:
    handler: sendmessage.index

resources:
  Resources:
    SthreeBucket: 
    ...
    hogehogeQueue:
      Type: AWS::SQS::Queue #Création de file d'attente SQS
      Properties:
        QueueName: "hogehoge-queue"

Maintenant, faites un `` sls deploy '' et lancez la fonction sendmessage et vous devriez voir le message ajouté à la file d'attente que vous avez créée.

Recevoir un message dans le déclencheur d'envoi d'un message à SQS

Ensuite, recevons le message que vous avez envoyé plus tôt. Créez `` Receivemessage.py '' et écrivez comme suit.

`receivemessage.py`


import json

def index(event, context):
    body = json.loads(event["Records"][0]["body"]) 
    message = body["message"]
    print(message)
    return message

Lorsque la fonction Lambda est démarrée en étant accrochée par SQS, le JSON suivant est passé au premier événement d'argument.

{
  "Records": [
    {
      "messageId": "19dd0b57-b21e-4ac1-bd88-01bbb068cb78",
      "receiptHandle": "MessageReceiptHandle",
      "body": "Hello from SQS!", 
      "attributes": {
        "ApproximateReceiveCount": "1",
        "SentTimestamp": "1523232000000",
        "SenderId": "123456789012",
        "ApproximateFirstReceiveTimestamp": "1523232000001"
      },
      "messageAttributes": {},
      "md5OfBody": "7b270e59b47ff90a553787216d55d91d",
      "eventSource": "aws:sqs",
      "eventSourceARN": "arn:aws:sqs:ap-northeast-1:123456789012:MyQueue",
      "awsRegion": "ap-northeast-1"
    }
  ]
}

Vous pouvez obtenir le message envoyé en récupérant le corps d'ici.

paramètres serverless.yml

`serverlss.yml`


...
functions:
  receivemessage:
    handler: receivemessage.index
    events:
      - sqs:
          # arn:aws:sqs:region:accountid:hogehoge-Devenir comme une file d'attente
          arn:
            Fn::Join:
            - ':'
            - - arn
              - aws
              - sqs
              - Ref: AWS::Region
              - Ref: AWS::AccountId
              - "hogehoge-queue"

Maintenant, lorsque vous faites `` sls deploy '' et que vous démarrez la fonction sendmessage, la fonction Receivemessage démarre. Notez que la fonction de message de réception sera toujours appelée si elle provoque une erreur. Dans ce cas, vous pouvez l'arrêter en effaçant le message de la file d'attente.

en conclusion

Supprimez-le si vous n'en avez pas besoin. La commande suivante le nettoiera.

sls remove

Le bucket ne disparaît pas bien. Dans ce cas, vous pouvez vider le bucket ou supprimer la pile directement.

J'ai pensé que je devrais essayer de toucher AWS car il existe divers autres services.

Touchez AWS avec Serverless Framework et Python

introduction

Préparation / environnement

1. Installez Serverless

2. Créez un utilisateur IAM et définissez les informations d'identification AWS

Créer un utilisateur IAM

Paramètres des informations d'identification AWS

3. Hello World avec Serverless Framework

handler.py

serverless.yml

4. Lancez Lambda depuis API Gate Way

serverless.yml

5. Enregistrez le fichier sur S3 et lisez-le

Créer une fonction pour enregistrer un fichier dans S3

sthreeput.py

paramètres serverless.yml

serverless.yml

Afficher le fichier déclenché par le fichier en cours d'enregistrement dans S3

sthreereceive.py

paramètres serverless.yml

serverless.yml

6. Envoyez un message à SQS et recevez le message

Créer une fonction pour envoyer un message à SQS

sendmessage.py

paramètres serverless.yml

serverless.yml

Recevoir un message dans le déclencheur d'envoi d'un message à SQS

receivemessage.py

paramètres serverless.yml

serverlss.yml

en conclusion

`handler.py`

`serverless.yml`

`serverless.yml`

`sthreeput.py`

`serverless.yml`

`sthreereceive.py`

`serverless.yml`

`sendmessage.py`

`serverless.yml`

`receivemessage.py`

`serverlss.yml`