Redmineにプラグインを入れる!

前置き

突然ですが、Redmineのガントチャートって激見づらくないですか?
そんな事象を解決するために、プラグインで解決しようじゃありませんか…


環境

LightSailのbitnamiを使ってRedmineが動いています。
     ↓こんな感じで動いてます↓


プラグインを入れる

①プラグインフォルダに移動してプラグインを入れる

cd ~/apps/redmine/htdocs/plugins

ここで、git clone なりでプラグインを引っ張ってきます。

②いったんhtdocsに戻ります

cd ../

③必要なものをインストールします

bundle install --no-deployment

④変更をマイグレーションします

bundle exec rake redmine:plugins:migrate RAILS_ENV=production

⑤再起動します

sudo /opt/bitnami/ctlscript.sh restart

■もしかすると、③を行った際に、mimemagicが~と怒られるかもしれませんが、安心してください。下記コマンドを実行すればおそらく解決します。

sudo apt install shared-mime-info

mimemagicの箇所でかなり手こずりました💦

Lambdaでもpipがしたい!

Lambdaでもpipしたいですよね….いろいろ面倒だし…..

やり方

①ローカルの作業ディレクトリにpipして使いたいものをためておきます。
  サンプルとして、pymsteamsを入れる形です。

pip install pymsteams -t .

 そうすると、作業ディレクトリにこんな感じでぶわっとファイルが量産されま  す↓

②それらをzipします。upload.zipだったりの名前にしておきます。

③作成したupload.zipをLambdaのアップロードでzip形式を選択後、該当ファイルをアップロード(既にアップロードされている状態….💦)

これでひとまず使えるようになりました…

レイヤーとかに追加してあげると、後で使うときに便利になるっぽいです。

AWS SESの送信クォータを監視する

AWSのSESには、送信クォータや送信レートという、アカウントごとに一定期間に送信できるメール数の上限が定められています。

送信クォータ
24時間のうちに何通のメールを送信できるか。上限を超えた場合には、送信クォータの上限に達した旨のエラーとなりメールが送信されなくなる(再送処理等はない)。

送信レート
SESが1秒間に受け入れ可能なメールの最大数です。この値を瞬間的に超えることは問題ありませんが、制限を超えた状態が長時間続く場合、送信クォータ同様メールの送信ができなくなる恐れがあります。

送信クォータの上限に達しているかどうかは、CloudWatchアラームなどでリアルタイムに監視するメトリクスが用意されておらず、SESのコンソールやAPIを通じて把握する必要があります。若干の面倒臭さが漂ってきますね。

送信レートの監視をする場合には秒間単位での監視になることや、上限を超えても直ちにペナルティが無いなどのはっきりとしない状況から、より明確なラインで確実な配信不能が訪れる送信クォータの監視をするのが良さそうです。

今回は、送信クォータの60%を消費した場合に、Slackに通知が来るようなLambda関数を紹介します。
※このLambda関数は、送信数に問題がない間は実行ログを吐き出す以外沈黙します。

Lambda関数

大まかな処理の流れは下記のとおりです。

  1. 送信クォータのステータスを取得
  2. 直近24時間の送信数 / 24時間での最大送信数 * 100 [%] を算出
  3. 60%以上消費していた場合、Slackへ通知(60%未満なら何もしない)
    1. 投稿メッセージを作成
    2. WebhookでSlackへPOST

Slackへの投稿はなるべく簡素にし、現在はメタデータなども含めないように(コメントアウト箇所)しています。

import boto3
import json
import urllib.request


def build_message_block(response, send_quota_usage):
    blocks = [
        {
            "type": "header",
            "text": {
                "type": "plain_text",
                "text": "SES Send quota use " + str(int(send_quota_usage)) + "%"
            }
        },
        {
            "type": "divider"
        },
        {
            "type": "section",
            "fields": [
                {
                    "type": "mrkdwn",
                    "text": "*SentLast24Hours (usage):* " + str(f"{int(response['SentLast24Hours']):,}")
                }
            ]
        },
        {
            "type": "section",
            "fields": [
                {
                    "type": "mrkdwn",
                    "text": "*Max24HourSend (limt):*   " + str(f"{int(response['Max24HourSend']):,}")
                }
            ]
        },
        {
            "type": "section",
            "fields": [
                {
                    "type": "mrkdwn",
                    "text": "*MaxSendRate:* " + str(f"{int(response['MaxSendRate']):,}")
                }
            ]
        }
    ]
    
    # if response['ResponseMetadata']:
    #     meta_data_json = json.dumps(response['ResponseMetadata'])
    #     blocks += [
    #         {
    #             "type": "section",
    #             "text": {
    #                 "type": "mrkdwn",
    #                 "text": "*ResponseMetadata:*\n```" + meta_data_json + "```"
    #             }
    #         }
    #     ]
    
    return blocks


def post_slack(blocks, message=None):
    send_data = {
        "channel": "XXXXXXXXXXX",   # SESの通知用channel
        "username": "SES Monitor",
        "icon_emoji": ":chart_with_upwards_trend:",
        "text": message,
        "blocks": blocks
    }
    send_text = "payload=" + json.dumps(send_data)
    
    print('post_slack() send_text: ', send_text)
    
    request = urllib.request.Request(
        "(SlackのWebhook URL)",
        data=send_text.encode('utf-8'),
        method="POST"
    )
    
    with urllib.request.urlopen(request) as response:
        response_body = response.read().decode('utf-8')


def get_ses_send_quota():
    ses = boto3.client('ses')
    response = ses.get_send_quota()
    send_quota_usage = response['SentLast24Hours'] / response['Max24HourSend'] * 100
    
    if send_quota_usage >= 60:
        message_body = build_message_block(response, send_quota_usage)
        notice_message = 'SES send quota usage: ' + str(send_quota_usage) + '%'
        print(message_body)
        print(notice_message)
        post_slack(message_body, notice_message)


def lambda_handler(event, context):
    get_ses_send_quota()
    
    return

Slackへの投稿内容をBlockで作成している都合上、どうしてもその箇所が長大になってしまっています……

Lambda関数に付与する権限

デフォルトのCloudWatchログ関係の他に、「AmazonSESReadOnlyAccess」を雑に付与してありました。もうちょっと精査しても良かったと思う。

実行方法

Lambda関数のトリガーに「EventBridge (CloudWatch Events)」を指定し、cronで定期実行しています。

送信されるメッセージの例

しきい値を下げてテストしたものがこちら。
※緩和申請済みのため送信クォータの上限が高いです。

これで、知らぬ間に送信クォータを使い果たしてメール配信不能に陥るような事故をケアすることができるようになりました。
緩和申請が間に合えば配信不能には陥りませんし、送信クォータの利用率がわからない状態で日々運用するよりも幾分精神衛生に良いと思います。

AWS SESのバウンス発生をSlackに通知する

こいついつもLambdaで何かやってるな。

AWSのSES(Simple Email Service)でバウンスや苦情が発生した際、それをSlackに通知することで、迅速な発生の検知と社内共有ができるようにしてみました。

「SESバウンス発生→SNSトピック呼び出し→SNSトピックからLambda関数を呼び出し」という流れでLambda関数に処理を渡しています。

Lambda関数

大まかな処理の流れは下記のとおりで、処理内容自体は単純です。
苦情の場合は配信抑制リストからの削除処理がありません。

  1. SNSトピックからLambdaが呼び出される。
  2. SNSトピックからのメッセージ内容を見て、バウンスか苦情かで処理を分岐する。
    1. バウンスの場合
      1. バウンス通知メッセージを作成する。
      2. 配信抑制リストから削除するアドレスの場合、削除する。
      3. 削除した場合、削除通知メッセージを通知に追加する。
      4. Slack通知を行うアドレスの場合、SlackへPOSTする。
    2. 苦情の場合
      1. 苦情通知メッセージを作成する。
      2. Slack通知を行うアドレスの場合、SlackへPOSTする。

SlackにPOSTするコンテンツをblock構造で記述しているせいで、非常にコードが長くなってしまっていまいました。見づらくて申し訳ありません。

import json
from datetime import date, datetime
import urllib.request

import boto3


def json_serial(obj):
    # If it is a date type, convert it to a character string.
    if isinstance(obj, (datetime, date)):
        return obj.isoformat()
    # Other than the above, it is not supported.
    raise TypeError ("Type %s not serializable" % type(obj))


def delete_suppressed_destination(mail):
    client = boto3.client('sesv2')

    suppressed = client.get_suppressed_destination(EmailAddress=mail)
    del_json = json.dumps(suppressed, default=json_serial)
    message = '\n'.join([
        '*Delete suppressed destination json*: `' + mail + '`',
        '```' + del_json + '```'
        ])

    try:
        client.delete_suppressed_destination(EmailAddress=mail)
    except client.exceptions.NotFoundException:
        post_slack('*NotFoundException*: `' + mail + '`\n' + message)
        return
    except client.exceptions.BadRequestException:
        post_slack('*BadRequestException*: `' + mail + '`\n' + message)
        return
    except client.exceptions.TooManyRequestsException:
        post_slack('*TooManyRequestsException*: `' + mail + '`\n' + message)
        return

    try:
        suppressed = client.get_suppressed_destination(EmailAddress=mail)
    except client.exceptions.NotFoundException:
        del_response = '*Deleted!*'
    except client.exceptions.BadRequestException:
        del_response = '*BadRequestException*'
    except client.exceptions.TooManyRequestsException:
        del_response = '*TooManyRequestsException*'

    return (del_response, del_json)


def is_no_suppress_mail(mail):
    if 'no-suppress' in mail or mail.endswith('@no.suppress.domain.jp'):
        return True
    return False
    
    
def is_ignore_mail(mail):
    ignore_list = (
        'ignore@example.com',
        )
    if mail in ignore_list or mail.endswith('@ignore.domain.jp'):
        return True
    return False


# Bounce.
def build_blocks_bounce(bounced_recipient, message_json):

    mail = bounced_recipient['emailAddress']

    diagnosticCode = bounced_recipient['diagnosticCode']
    bounce_status = '\n'.join((
        'action: ' + bounced_recipient['action'],
        'status: ' + bounced_recipient['status'],
        'diagnostic_code: ' + diagnosticCode,
        ))

    bounce_json = json.dumps(message_json)

    blocks = [
        {
            "type": "section",
            "fields": [
                {
                    "type": "mrkdwn",
                    "text": "*Mail: *"
                },
                {
                    "type": "mrkdwn",
                    "text": "`" + mail + "`"
                }
            ]
        },
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "*Bounced information: *\n```" + bounce_status + "```"
			}
		},
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "*Bounced message json: *\n```" + bounce_json + "```"
			}
		}
    ]
    return blocks

def build_blocks_delete(mail, del_response, del_json):
    blocks = [
        {
            "type": "header",
            "text": {
                "type": "plain_text",
                "text": "Delete notification"
            }
        },
        {
            "type": "divider"
        },
        {
            "type": "section",
            "fields": [
                {
                    "type": "mrkdwn",
                    "text": "*Mail:*"
                },
                {
                    "type": "mrkdwn",
                    "text": "`" + mail + "`"
                }
            ]
        },
        {
            "type": "section",
            "fields": [
                {
                    "type": "mrkdwn",
                    "text": "*Response:*"
                },
                {
                    "type": "mrkdwn",
                    "text": del_response
                }
            ]
        },
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "*Suppressed destination json: *\n```" + del_json + "```"
			}
		}
    ]
    return blocks

def prepare_bounced_message(message_json):
    bounced_message = [
        {
            "type": "header",
            "text": {
                "type": "plain_text",
                "text": "Bounce notification"
            }
        },
        {
            "type": "divider"
        },
		{
			"type": "section",
            "fields": [
                {
                    "type": "mrkdwn",
                    "text": "*Timestamp (UTC): *"
                },
                {
                    "type": "mrkdwn",
                    "text": "`" + message_json['bounce']['timestamp'] + "`"
                }
            ]
		}
    ]
    return bounced_message


# Complaint.
def build_blocks_complaint(complained_recipient, message_json):

    mail = complained_recipient['emailAddress']

    complaint_json = json.dumps(message_json)

    blocks = [
        {
            "type": "section",
            "fields": [
                {
                    "type": "mrkdwn",
                    "text": "*Mail: *"
                },
                {
                    "type": "mrkdwn",
                    "text": "`" + mail + "`"
                }
            ]
        },
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "*Complaintd message json: *\n```" + complaint_json + "```"
			}
		}
    ]
    return blocks

def prepare_complained_message(message_json):
    complained_message = [
        {
            "type": "header",
            "text": {
                "type": "plain_text",
                "text": "Complaint notification"
            }
        },
        {
            "type": "divider"
        },
		{
			"type": "section",
            "fields": [
                {
                    "type": "mrkdwn",
                    "text": "*Timestamp (UTC): *"
                },
                {
                    "type": "mrkdwn",
                    "text": "`" + message_json['complaint']['timestamp'] + "`"
                }
            ]
		}
    ]
    return complained_message


def post_slack(blocks, message=None):
    send_data = {
        "channel": "XXXXXXXXXXX",   # SESの通知用Channel-ID
        "username": "SES Notice",
        "icon_emoji": ":mailbox_with_no_mail:",
        "text": message,
        "blocks": blocks
    }

    send_text = "payload=" + json.dumps(send_data)

    print('post_slack() send_text: ', send_text)

    request = urllib.request.Request(
        "(SlackのWebhook URL)",
        data=send_text.encode('utf-8'),
        method="POST"
    )

    with urllib.request.urlopen(request) as response:
        response_body = response.read().decode('utf-8')


def ses_process(event):
    message_json = json.loads(event['Records'][0]['Sns']['Message'])

    if message_json['notificationType'] == 'Bounce':
        bounced_recipients = message_json['bounce']['bouncedRecipients']
        bounced_mails = []
        delete_result = []
        notice_message = ""

        for bounced_recipient in bounced_recipients:
            bounced_mails += build_blocks_bounce(bounced_recipient, message_json)
            mail = bounced_recipient['emailAddress']
            if is_no_suppress_mail(mail) and not is_ignore_mail(mail):
                del_result, del_json = delete_suppressed_destination(mail)
                delete_result += build_blocks_delete(mail, del_result, del_json)
                notice_message = "DELETE: " + mail

        bounced_message = prepare_bounced_message(message_json)
        bounced_message = bounced_message + bounced_mails + delete_result

        if not notice_message:
            notice_message = "BOUNCE: " + mail
            
        if not is_ignore_mail(mail):
            post_slack(bounced_message, notice_message)

    elif message_json['notificationType'] == 'Complaint':
        complained_recipients = message_json['complaint']['complainedRecipients']
        complained_mails = []

        for complained_recipient in complained_recipients:
            complained_mails += build_blocks_complaint(complained_recipient, message_json)
            mail = complained_recipient['emailAddress']

        complained_message = prepare_complained_message(message_json)
        complained_message = complained_message + complained_mails
        notice_message = "COMPLAINT: " + mail
        
        if not is_ignore_mail(mail):
            post_slack(complained_message, notice_message)

    return


def lambda_handler(event, context):
    if event['Records'][0]['EventSource'] == 'aws:sns' :
        ses_process(event)

    return

例外処理が甘いですね。

権限については実装当時に精査していなかったようで、「AmazonSESFullAccess」を付与されていましたが、get_suppressed_destination()delete_suppressed_destination()をする権限くらいがあれば動きそうです。甘々ですね。

細かい処理についての補足……?

is_no_suppress_mail(mail)

SESではバウンスの発生時に、配信抑制リスト(suppression-list)というものにメールアドレスを登録し、メールのバウンスが再発することを防止する仕組みがあります。

この仕組みは便利なもので活用したいのですが、一時的な問題でバウンスが発生することが度々ある等、特定のアドレスだけは抑制リストに入らないでほしいようなケースがあるかもしれません。

こういったケースでは、抑制リストに登録された直後にリストから自動で登録解除することで、擬似的にリストに登録されないような状態にすることができます。(バウンスレートが急上昇するリスクもあるので、運用時は要注意)

この「自動で配信抑制リストから削除するアドレス」かを判定する関数が is_no_suppress_mail(mail) です。

is_ignore_mail(mail)

Slackへ通知したくないメールアドレス(既知のダミーアドレス等)もあるため、通知を送らないアドレスのリストを用意します。

Slack通知の有無を判定する際に用いる判定関数が is_ignore_mail(mail) です。

build_blocks_bounce(), build_blocks_delete(), prepare_bounced_message() 等

SNSトピックから受け取ったメッセージを元に、見やすく整形してSlackにPOSTするコンテンツを作成します。

実際の投稿の様子

コードの短さを犠牲に情報が見やすい投稿を実現しています。

バウンス通知(Bounce)
バウンス通知(配信抑制リストにあるもの)
バウンス通知+削除通知(Bounce+Delete)
苦情通知(Complaint)

Lambda 不要なAMIとスナップショットをまとめて削除する

起動テンプレート自動更新起動設定自動更新の記事を投稿しましたが、こういう自動化をしていると、気づけばAMIが山のように溜まってしまいます。

AMIに紐付いたスナップショットは、(大抵の場合少額とはいえ)ストレージ料金が発生します。

AWSコンソールのAMIのページから、不要なAMIを登録解除することがあると思いますが、紐付いたスナップショットまでは自動で消えてくれません。

紐付いたスナップショットをスナップショットの画面から検索して削除するのが地味に面倒だったので、一括削除できるようなLambda関数を作ってしまいます。

Lambda関数

処理の流れはシンプルで、「AMI削除→紐付いたスナップショットを検索して削除」という処理を、与えられたAMIのリストを回して繰り返し行うだけです。

import boto3
import logging
from botocore.exceptions import ClientError


ec2 = boto3.client('ec2')


def unregister_ami(delete_ami_id):
    # Unregister AMI.
    try:
        response = ec2.deregister_image(ImageId=str(delete_ami_id))
    except ClientError as e:
        if e.response['Error']['Code'] == 'InvalidAMIID.Unavailable':
            print('InvalidAMIID.Unavailable: ' + delete_ami_id)
            return True
        elif e.response['Error']['Code'] == 'InvalidAMIID.NotFound':
            print('InvalidAMIID.NotFound: ' + delete_ami_id)
            return True
        else:
            print(e.response['Error']['Code'])
            print(e.response['Error']['Message'])
            raise e
    print('Unregister AMI: ' + delete_ami_id)
    return response.get('ResponseMetadata', {}).get('HTTPStatusCode', -1) == 200


def delete_related_snapshots(delete_ami_id):
    # Get target snapshots.
    try:
        response = ec2.describe_snapshots(
            Filters=[
                {
                    'Name': 'description',
                    'Values': ['Created by CreateImage(*) for ' + delete_ami_id + '*',]
                }
            ]
        )
    except ClientError as e:
        print(e.response['Error']['Code'])
        print(e.response['Error']['Message'])
        raise e

    # Delete target snapshots.
    for snapshot in response['Snapshots']:
        try:
            response = ec2.delete_snapshot(SnapshotId=snapshot['SnapshotId'])
            if response.get('ResponseMetadata', {}).get('HTTPStatusCode', -1) != 200:
                raise('# Cannot delete snapshot: %s', snapshot)
            print('Delete Snapshot: ' + snapshot['SnapshotId'])
        except ClientError as e:
            print(e.response['Error']['Code'])
            print(e.response['Error']['Message'])
            logging.error("# Delete snapshot error: %s", e)
        
    return


def lambda_handler(event, context):
    delete_amis = event['delete_amis']
    print(delete_amis)

    for delete_ami in delete_amis:
        # Delete AMI.
        unregister_ami(delete_ami)
    
        # Delete Snapshots.
        delete_related_snapshots(delete_ami)
    
    return

Lambda関数には、以下の権限を付与します。

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "VisualEditor0",
            "Effect": "Allow",
            "Action": [
                "ec2:DeregisterImage",
                "ec2:DeleteSnapshot",
                "ec2:DescribeSnapshots"
            ],
            "Resource": "*"
        },
        {
            "Sid": "VisualEditor1",
            "Effect": "Allow",
            "Action": "logs:CreateLogGroup",
            "Resource": (略)
        },
        {
            "Sid": "VisualEditor2",
            "Effect": "Allow",
            "Action": [
                "logs:CreateLogStream",
                "logs:PutLogEvents"
            ],
            "Resource": (略)
        }
    ]
}

使い方

  1. AWSコンソールのAMIの画面で、不要なAMIをチェックしていきます。
  2. 画面下部にチェックしたAMIのidがずらずらと表示されるので、これをコピーします。
  3. 適当なエディタで整形し、Lambda関数のテストイベントに下記のようなデータを投入して実行すれば、AMIとスナップショットが削除されます。
{
    "delete_amis": [
        "ami-0123456789abcdef1",
        "ami-0123456789abcdef2",
        "ami-0123456789abcdef3"
    ]
}

余談

スナップショットの削除部分のみをLambda関数で作っておき、AMIの削除操作を行った際に、自動で関連スナップショットを削除するようなことも可能(CloudTrail利用)で、そのようにした方が効率的で良いかと思います。

一方であまり削除処理系を自動化しすぎると、大事なデータの消失などが発生する懸念もあるため、「起動テンプレートの更新処理に連動して古い起動テンプレートや古いAMIを削除する」ような処理の実装は控えています。

参考