Créer un programme périodique avec Ruby x AWS Lambda x CloudWatch Events

Configuration visée dans cet article

Lancez Lambda déclenché par CloudWatch Events et envoyez un message à Slack.

• Définissez le calendrier d'exécution à l'avance en utilisant la formule Cron pour CloudWatch Events.

↑ Il sera automatiquement exécuté régulièrement comme ceci.

Public cible

--Les personnes qui souhaitent créer des programmes d'exécution réguliers dans Ruby --Les personnes qui veulent toucher Lambda

spécification

Langue: série Ruby 2.5 Infrastructure: Lambda, événements ClowdWatch

• Veuillez créer votre propre SlackBot à l'avance.

Référence: [Création d'un bot à utiliser dans l'espace de travail](https://slack.com/intl/ja-jp/help/articles/115005265703-%E3%83%AF%E3%83%BC%E3%82% AF% E3% 82% B9% E3% 83% 9A% E3% 83% BC% E3% 82% B9% E3% 81% A7% E5% 88% A9% E7% 94% A8% E3% 81% 99% E3% 82% 8B% E3% 83% 9C% E3% 83% 83% E3% 83% 88% E3% 81% AE% E4% BD% 9C% E6% 88% 90)

Formulaire rempli

periodic-slack-bot-on-aws-lambda

• Si vous avez du mal à créer à partir de zéro, veuillez cloner git depuis ↑.

Créer un programme

Créez un programme pour envoyer des messages à Slack.

Créer un annuaire

$ mkdir periodic-slack-bot-on-aws-lambda
$ cd periodic-slack-bot-on-aws-lambda

Définir Git

$ git init
$ touch .gitignore

:./.gitignore

.bundle
/vendor/bundle

Décrivez ce que vous ne souhaitez pas gérer avec Git.

Spécifier la version de Ruby

$ rbenv local 2.5.1 
# 2.5 séries recommandées

Installer Gem

$ bundle init

Générez un Gemfile avec la commande ↑ et éditez-le comme suit.

./Gemfile

# frozen_string_literal: true

source "https://rubygems.org"

git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }

ruby '2.5.1'

gem 'async-websocket'
gem 'slack-ruby-bot'

Ensuite, installez le Gem requis.

$ bundle install --path vendor/bundle

• Puisqu'il est nécessaire de conditionner le Gem dans un fichier zip plus tard, il doit être installé sous "vendeur / bundle" (local) au lieu de globalement.

Créer app.rb

$ touch app.rb

ruby:./app.rb

require 'slack-ruby-client'

Slack.configure do |conf|
  conf.token = ENV['SLACK_BOT_TOKEN']
end

def post_to_slack(event:, context:)
  client = Slack::Web::Client.new
  client.chat_postMessage(channel: ENV['SLACK_CHANNEL_NAME'], text: 'Soumission de test depuis AWS Lambda', as_user: true)
end

• Notez que cela ne fonctionnera que si vous passez "(event:, context :)" comme argument. Article de référence: AWS Lambda Function Handler for Python

Déployer sur Lambda

Après avoir créé le programme, préparez-vous à le déployer sur Lambda.

Installez l'AWS CLI

Cette fois, nous procéderons au déploiement à l'aide d'un outil appelé «AWS CLI», donc si vous ne l'avez pas encore installé, installez-le.

$ brew install awscli

Créer un utilisateur IAM

Créez un utilisateur IAM pour le déploiement. Tout d'abord, allez dans "IAM" -> "Stratégie" -> "Créer une stratégie" et collez l'instruction suivante à partir de l'onglet JSON.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "apigateway:*",
                "cloudformation:*",
                "dynamodb:*",
                "events:*",
                "iam:*",
                "lambda:*",
                "logs:*",
                "route53:*",
                "s3:*"
             ],
            "Resource": [
                "*"
            ]
        }
    ]
}

Voir aussi: Stratégie IAM de déploiement minimal (https://rubyonjets.com/docs/extras/minimal-deploy-iam/)

Entrez le nom et la description de la politique, le cas échéant, puis cliquez sur «Créer une politique».

Ensuite, allez dans "IAM" -> "Utilisateur" -> "Créer un utilisateur", donnez-lui un nom approprié, cochez "Accès par programme" et passez au suivant.

Sélectionnez «Déploiement minimal de la stratégie IAM» créée précédemment à partir de «Joindre directement la stratégie existante» et passez à la suivante.

(Les balises sont facultatives) Un écran de confirmation s'affichera à la fin, donc s'il n'y a pas de problème, cliquez sur "Créer un utilisateur".

Ensuite, deux «ID de clé d'accès» et «clé d'accès secrète» seront émis, alors gardez-le en lieu sûr pendant que vous téléchargez le fichier csv ou que vous en prenez note.

Paramètres de l'AWS CLI

$ aws configure --profil lambda (tout nom de profil est OK)

AWS Access Key ID #ID de clé d'accès créé précédemment
AWS Secret Access Key #La clé d'accès secrète que vous avez créée précédemment
Default region name # ap-northeast-1 
Default output format # json 

Lorsque vous tapez "aws configure" dans le terminal, il vous sera demandé différentes choses de manière interactive, alors entrez les informations nécessaires pour chacune.

Créer une fonction

Ouvrez «AWS Lambda» depuis l'écran de la console AWS et cliquez sur «Créer une fonction».

--Nom de la fonction (nom arbitraire) --Durée (Ruby2.5)

Pour créer une fonction. (D'autres sont OK avec les valeurs par défaut ou les blancs)

Depuis "Modifier les variables d'environnement"

• SLACK_BOT_TOKEN
• SLACK_CHANNEL_NAME

Définissez des variables d'environnement pour chacun.

Changement du nom du gestionnaire de "Modifier les paramètres de base" à "app.post_to_slack (nom de fichier.nom de méthode)".

Déployer

Empaquetez le programme créé sous forme de fichier zip.

$ zip -r function.zip app.rb vendor

Déployez en utilisant aws cli.

$ aws lambda update-function-code --function-name PeriodicSlackBotOnAwsLambda --zip-file fileb://function.zip --profile lambda

{
    "FunctionName": "PeriodicSlackBotOnAwsLambda",
    "FunctionArn": "arn:aws:lambda:ap-northeast-1:**************:function:PeriodicSlackBotOnAwsLambda",
    "Runtime": "ruby2.5",
    "Role": "arn:aws:iam::**************:role/service-role/PeriodicSlackBotOnAwsLambda-role-**************",
    "Handler": "app.post_to_slack",
    "CodeSize": 12941753,
    "Description": "",
    "Timeout": 3,
    "MemorySize": 128,
    "LastModified": "2020-10-09T21:08:11.888+0000",
    "CodeSha256": "**************/**************=",
    "Version": "$LATEST",
    "Environment": {
        "Variables": {
            "SLACK_CHANNEL_NAME": "#**************",
            "SLACK_BOT_TOKEN": "xoxb-**************-**************-**************"
        }
    },
    "TracingConfig": {
        "Mode": "PassThrough"
    },
    "RevisionId": "********-****-****-****-********",
    "State": "Active",
    "LastUpdateStatus": "Successful"
}

• Définissez le nom de la fonction créée précédemment dans --function-name.

Essai

Créez un test approprié à partir de "Paramètres d'événement de test". (Le hachage peut être laissé vide)

Cliquez sur "Test" et si le message est envoyé au canal Slack spécifié, il réussit.

Gestion des horaires avec CloudWatch Events

Paramètres de déclenchement

Cliquez sur "Ajouter un déclencheur".

--Nom du déclencheur: CloudWatch Events --Rule: créer une nouvelle règle --Nom de la règle: test_30minutes (facultatif)

• Description de la règle: Exécuter une fois toutes les 30 minutes (facultatif) --Type de règle: expression de planification
• Calendrier: cron (* / 30 * * *? *)

• Définissez l'intervalle d'exécution comme vous le souhaitez.

L'explication de la façon d'écrire une expression cron est omise cette fois. Voir: Touch the cron

Attendez le passage du temps, et s'il est exécuté régulièrement, il réussira.

Si cela ne fonctionne pas, le journal doit être sorti dans le groupe de journaux CloudWatch, donc déboguez-le de manière appropriée.

Épilogue

Je vous remercie pour votre travail acharné! Si vous procédez selon l'article et qu'il y a une partie qui ne fonctionne pas bien, j'apprécierais que vous puissiez la signaler dans le commentaire orchidée.