LaravelをECS上で運用するTips

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

locals {
  base_name = "${var.base_name}-ecs-notification"
}
resource "aws_cloudwatch_event_rule" "main" {
  name = local.base_name
  event_pattern = jsonencode({
    "source" : [
      "aws.ecs"
    ],
    "detail-type" : [
      "ECS Task State Change"
    ],
    "detail" : {
      "clusterArn" : [
        var.cluster_arn
      ]
    }
  })
}

resource "aws_cloudwatch_log_group" "lambda_log" {
  name = "/aws/lambda/${local.base_name}-lambda"
}

resource "aws_iam_role" "lambda" {
  name = local.base_name
  assume_role_policy = jsonencode({
    Version = "2012-10-17"
    Statement : [
      {
        Action = "sts:AssumeRole"
        Principal = {
          Service = "lambda.amazonaws.com"
        }
        Effect = "Allow"
      }
    ]
  })
}

resource "aws_iam_policy" "lambda" {
  policy = jsonencode(
    {
      Version = "2012-10-17",
      Statement = [
        {
          Effect = "Allow",
          Action = [
            "logs:CreateLogStream",
            "logs:PutLogEvents"
          ],
          Resource = [
            aws_cloudwatch_log_group.lambda_log.arn
          ]
        }
      ]
    }
  )
}
resource "aws_iam_role_policy_attachment" "lambda" {
  policy_arn = aws_iam_policy.lambda.arn
  role       = aws_iam_role.lambda.name
}

data "archive_file" "lambda" {
  source_file = "${path.module}/lambda/index.js"
  output_path = "${path.module}/lambda/index.zip"
  type        = "zip"
}

resource "aws_lambda_permission" "from_cw_event" {
  action        = "lambda:InvokeFunction"
  function_name = aws_lambda_function.main.function_name
  source_arn    = aws_cloudwatch_event_rule.main.arn
  principal     = "events.amazonaws.com"
}

resource "aws_lambda_function" "main" {
  function_name    = local.base_name
  handler          = "index.handler"
  role             = aws_iam_role.lambda.arn
  runtime          = "nodejs12.x"
  filename         = data.archive_file.lambda.output_path
  source_code_hash = data.archive_file.lambda.output_base64sha256
  environment {
    variables = {
      SLACK_CHANNEL  = var.slack_channel
      SLACK_ICON     = var.slack_icon
      SLACK_APP_NAME = local.base_name
      SLACK_HOOK_URL = var.slack_hook_url
    }
  }
}
resource "aws_cloudwatch_event_target" "main" {
  arn  = aws_lambda_function.main.arn
  rule = aws_cloudwatch_event_rule.main.name
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

'use strict';

const https = require('https');
const url = require('url');

// envs
const SLACK_CHANNEL = process.env.SLACK_CHANNEL
const SLACK_ICON = process.env.SLACK_ICON
const SLACK_APP_NAME = process.env.SLACK_APP_NAME
const SLACK_HOOK_URL = process.env.SLACK_HOOK_URL

exports.handler = async (event, context, callback) => {
    const eventDetail = event.detail
    if (!eventDetail) {
        console.log("The event is not expected", event)
    }

    const message = genNotifyMessage(eventDetail)
    if (!message) {
        return
    }

    const result = await sendSlack(message)
    console.log(result)
}

function genNotifyMessage(eventDetail) {
    const targetStatuses = [
        {
            from: "PENDING",
            to: "RUNNING",
            message: `${eventDetail.group} deploy started`
        },
        {
            from: "RUNNING",
            to: "RUNNING",
            message: `${eventDetail.group} deploy completed`
        }
    ]

    const target = targetStatuses
        .find(({from, to}) => from === eventDetail.lastStatus && to === eventDetail.desiredStatus)

    return target && target.message
}

function sendSlack(message) {
    return new Promise(((resolve, reject) => {

        const formData = {
            channel: SLACK_CHANNEL,
            text: message,
            icon_emoji: SLACK_ICON,
            username: SLACK_APP_NAME,
        };

        const formDataEncripted = JSON.stringify(formData)

        const options = {
            ...url.parse(SLACK_HOOK_URL),
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Content-Length': Buffer.byteLength(formDataEncripted)
            }
        };

        const req = https.request(options, function (res) {
            let chunks = []
            res.on('data', function (chunk) {
                chunks.push(chunk)
            });
            res.on('end', function () {
                console.log(chunks.join(''))
                resolve({
                    body: chunks.join(''),
                    statusCode: res.statusCode,
                    statusMessage: res.statusMessage
                })
            })
        });

        req.write(formDataEncripted);

        req.on('error', function (e) {
            console.log("Sending request error: " + e.message);
            reject(e)
        });

        req.end();
    }))
}