AWS LambdaとAPI Gatewayを利用し、PagerDutyのインシデント発生時にSlackに専用チャンネルを作成する #2

■ ソースコードをローカル環境に準備する

tanaka@ubuntu:~$ mkdir -p ~/work/pd2slack
tanaka@ubuntu:~$ touch ~/work/pd2slack/index.js

tanaka@ubuntu:~$ cat ~/work/pd2slack/index.js
'use strict';
console.log('Loading function');
exports.handler = (event, context, callback) => {
  console.log('Received event:', JSON.stringify(event, null, 2));
  callback(null, 'success!');
};

■ S3のバケットを用意し、ソースコードをzipファイルに圧縮してアップロードする

tanaka@ubuntu:~$ aws s3 mb s3://***********-pd2slack
make_bucket: s3://***********-pd2slack/

tanaka@ubuntu:~$ aws s3 ls
2016-04-10 18:48:46 ***********-pd2slack

tanaka@ubuntu:~$ cd ~/work/pd2slack/
tanaka@ubuntu:~/work/pd2slack$ zip -r ~/work/pd2slack.zip ./*
  adding: index.js (deflated 25%)

tanaka@ubuntu:~/work/pd2slack$ aws s3 cp ~/work/pd2slack.zip s3://***********-pd2slack/
upload: ../pd2slack.zip to s3://***********-pd2slack/pd2slack.zip

tanaka@ubuntu:~/work/pd2slack$ aws s3 ls s3://***********-pd2slack/
2016-04-10 19:45:47        319 pd2slack.zip

■ アップロードしたzipファイルをソースコードに指定して、Lambda関数を作成する

tanaka@ubuntu:~/work/pd2slack$ aws lambda create-function --function-name 'pd2slack' \
  --runtime 'nodejs4.3' --role 'arn:aws:iam::************:role/lambda_basic_execution' \
  --handler 'index.handler' --code 'S3Bucket=***********-pd2slack,S3Key=pd2slack.zip' \
  --description 'Post message from PagerDuty to Slack.' --timeout 10 --memory 128 --publish
{
    "CodeSha256": "********************************************",
    "FunctionName": "pd2slack",
    "CodeSize": 319,
    "MemorySize": 128,
    "FunctionArn": "arn:aws:lambda:ap-northeast-1:************:function:pd2slack",
    "Version": "1",
    "Role": "arn:aws:iam::************:role/lambda_basic_execution",
    "Timeout": 10,
    "LastModified": "2016-04-10T11:03:33.533+0000",
    "Handler": "index.handler",
    "Runtime": "nodejs4.3",
    "Description": "Post message from PagerDuty to Slack."
}

tanaka@ubuntu:~$ aws lambda list-functions
{
    "Functions": [
        {
            "Version": "$LATEST",
            "CodeSha256": "********************************************",
            "FunctionName": "pd2slack",
            "MemorySize": 128,
            "CodeSize": 319,
            "FunctionArn": "arn:aws:lambda:ap-northeast-1:************:function:pd2slack",
            "Handler": "index.handler",
            "Role": "arn:aws:iam::************:role/lambda_basic_execution",
            "Timeout": 10,
            "LastModified": "2016-04-10T11:03:33.533+0000",
            "Runtime": "nodejs4.3",
            "Description": "Post message from PagerDuty to Slack."
        },
        {
            "Version": "$LATEST",
            "CodeSha256": "********************************************",
            "FunctionName": "test",
            "VpcConfig": {
                "SubnetIds": [],
                "SecurityGroupIds": []
            },
            "MemorySize": 128,
            "CodeSize": 282,
            "FunctionArn": "arn:aws:lambda:ap-northeast-1:************:function:test",
            "Handler": "index.handler",
            "Role": "arn:aws:iam::************:role/lambda_basic_execution",
            "Timeout": 10,
            "LastModified": "2016-04-10T10:27:39.225+0000",
            "Runtime": "nodejs4.3",
            "Description": "test"
        }
    ]
}

■ API Gatewayで作成したLambda関数を公開する

■ API Tokenを用意する

■ Slack-node npmについて

tanaka@ubuntu:~$ cd ~/work/pd2slack/
tanaka@ubuntu:~/work/pd2slack$ npm install slack-node
/home/tanaka/work/pd2slack
└─┬ slack-node@0.2.0
    └─┬ requestretry@1.6.0
        ├─┬ fg-lodash@0.0.2
        │  ├── lodash@2.4.2
        │  └── underscore.string@2.3.3
        ├─┬ request@2.70.0
        │  ├── aws-sign2@0.6.0
        │  ├─┬ aws4@1.3.2
        │  │  └─┬ lru-cache@4.0.1
        │  │      ├── pseudomap@1.0.2
        │  │      └── yallist@2.0.0
        │  ├─┬ bl@1.1.2
        │  │  └─┬ readable-stream@2.0.6
        │  │      ├── core-util-is@1.0.2
        │  │      ├── inherits@2.0.1
        │  │      ├── isarray@1.0.0
        │  │      ├── process-nextick-args@1.0.6
        │  │      ├── string_decoder@0.10.31
        │  │      └── util-deprecate@1.0.2
        │  ├── caseless@0.11.0
        │  ├─┬ combined-stream@1.0.5
        │  │  └── delayed-stream@1.0.0
        │  ├── extend@3.0.0
        │  ├── forever-agent@0.6.1
        │  ├─┬ form-data@1.0.0-rc4
        │  │  └── async@1.5.2
        │  ├─┬ har-validator@2.0.6
        │  │  ├─┬ chalk@1.1.3
        │  │  │  ├── ansi-styles@2.2.1
        │  │  │  ├── escape-string-regexp@1.0.5
        │  │  │  ├─┬ has-ansi@2.0.0
        │  │  │  │  └── ansi-regex@2.0.0
        │  │  │  ├── strip-ansi@3.0.1
        │  │  │  └── supports-color@2.0.0
        │  │  ├─┬ commander@2.9.0
        │  │  │  └── graceful-readlink@1.0.1
        │  │  ├─┬ is-my-json-valid@2.13.1
        │  │  │  ├── generate-function@2.0.0
        │  │  │  ├─┬ generate-object-property@1.2.0
        │  │  │  │  └── is-property@1.0.2
        │  │  │  ├── jsonpointer@2.0.0
        │  │  │  └── xtend@4.0.1
        │  │  └─┬ pinkie-promise@2.0.1
        │  │      └── pinkie@2.0.4
        │  ├─┬ hawk@3.1.3
        │  │  ├── boom@2.10.1
        │  │  ├── cryptiles@2.0.5
        │  │  ├── hoek@2.16.3
        │  │  └── sntp@1.0.9
        │  ├─┬ http-signature@1.1.1
        │  │  ├── assert-plus@0.2.0
        │  │  ├─┬ jsprim@1.2.2
        │  │  │  ├── extsprintf@1.0.2
        │  │  │  ├── json-schema@0.2.2
        │  │  │  └── verror@1.3.6
        │  │  └─┬ sshpk@1.7.4
        │  │      ├── asn1@0.2.3
        │  │      ├─┬ dashdash@1.13.0
        │  │      │  └── assert-plus@1.0.0
        │  │      ├── ecc-jsbn@0.1.1
        │  │      ├── jodid25519@1.0.2
        │  │      ├── jsbn@0.1.0
        │  │      └── tweetnacl@0.14.3
        │  ├── is-typedarray@1.0.0
        │  ├── isstream@0.1.2
        │  ├── json-stringify-safe@5.0.1
        │  ├─┬ mime-types@2.1.10
        │  │  └── mime-db@1.22.0
        │  ├── node-uuid@1.4.7
        │  ├── oauth-sign@0.8.1
        │  ├── qs@6.1.0
        │  ├── stringstream@0.0.5
        │  ├── tough-cookie@2.2.2
        │  └── tunnel-agent@0.4.2
        └── when@3.7.7

■ Node.jsでLambda関数を開発する環境を用意する

001: 'use strict';
002: console.log('Loading function');
003:
004: var SLACK_API_TOKEN = '****-***********-***********-***********-**********';
005: var CHANNEL_NAME_PREFIX = 'incident_';
006:
007: var Slack = require('slack-node');
008: var slack = new Slack(SLACK_API_TOKEN);
009:
010: var SlackUtil = {
011:   makeChannelName: (message) => {
012:     return CHANNEL_NAME_PREFIX + message.data.incident.incident_number;
013:   },
014:   createChannelIfNotExists: (channel_name) => {
015:     return new Promise((resolve, reject) => {
016:       slack.api(
017:         'channels.list',
018:         {exclude_archived: 1},
019:         (err, res) => {
020:           if (!err && res.ok) {
021:             if (
022:               !res.channels.some((channel, i, c) => {
023:                 if (channel.name == channel_name) {
024:                   console.log('Channel found. (' + channel_name + ')');
025:                   resolve(channel);
026:                   return true;
027:                 }
028:                 return false;
029:               })
030:             ) {
031:               console.log('Channel not found. (' + channel_name + ')');
032:               resolve(null);
033:             }
034:             return;
035:           }
036:           reject(
037:             new Error(
038:               'Can not get channnel list. ('
039:                 + 'Error: ' + JSON.stringify(res, null, 2)
040:                 + ', Response: ' + JSON.stringify(res, null, 2) + ')'
041:             )
042:           );
043:         }
044:       );
045:     }).then((channel) => {
046:       if (channel) {
047:         return Promise.resolve(channel);
048:       }
049:       return new Promise((resolve, reject) => {
050:         slack.api(
051:           'channels.create',
052:           {name: channel_name},
053:           (err, res) => {
054:             if (!err && res.ok) {
055:               console.log('Channel created. (ID:' + res.channel.id
                                        + ', Name:' + channel_name + ')');
056:               resolve(res.channel);
057:               return;
058:             }
059:             reject(
060:               new Error(
061:                 'Can not create channnel. ('
062:                   + 'Error: ' + JSON.stringify(res, null, 2)
063:                   + ', Response: ' + JSON.stringify(res, null, 2) + ')'
064:               )
065:             );
066:           }
067:         );
068:       });
069:     }).catch((error) => {
070:       console.error(error);
071:     });
072:   }
073: }
074:
075: exports.handler = (event, context, callback) => {
076:
077:   if (
078:     typeof event.messages !== 'undefined' &&
079:     Array.isArray(event.messages)
080:   ) {
081:
082:     console.log(JSON.stringify(event, null, 2));
083:
084:     var channels = new Map();
085:
086:     console.log('Creating channels...');
087:     Promise.all(
088:       event.messages.map((message, i, m) => {
089:         var channel_name = SlackUtil.makeChannelName(message);
090:         return SlackUtil.createChannelIfNotExists(channel_name);
091:       })
092:     }).then((results) => {
093:       console.log('done.');
094:       callback(null, 'done.');
095:     });
096:
097:   }
098:
099: }

■ 作成したコードをLambdaにデプロイしテストする

#! /bin/sh
rm -f ~/work/pd2slack.zip
rm -f /tmp/pd2slack_test_results.txt
cd ~/work/pd2slack/
zip -qr ~/work/pd2slack.zip ./*
aws s3 cp ~/work/pd2slack.zip s3://***********-pd2slack/
aws lambda update-function-code --function-name 'pd2slack' \
    --s3-bucket '***********-pd2slack' --s3-key 'pd2slack.zip' --publish

#! /bin/sh
aws lambda invoke --function-name 'pd2slack' --log-type Tail \
    --payload file://~/work/pd2slack_input.txt /tmp/pd2slack_test_results.txt \
        | jq -r .LogResult | base64 --decode

2016-04-13T04:04:05.809Z  *  Creating channels...
2016-04-13T04:04:07.068Z  *  Channel not found. (incident_131)
2016-04-13T04:04:07.469Z  *  Channel created. (ID:C105L7XEX, Name:incident_131)
2016-04-13T04:04:07.470Z  *  done.

2016-04-13T04:11:08.140Z  *  Creating channels...
2016-04-13T04:11:08.340Z  *  Channel found. (incident_131)
2016-04-13T04:11:08.340Z  *  done.

■ 作成したインシデント専用チャンネルに対して処理を行う

001: 'use strict';
002: console.log('Loading function');
003:
004: var SLACK_API_TOKEN = '****-***********-***********-***********-**********';
005: var CHANNEL_NAME_PREFIX = 'incident_';
006:
007: var Slack = require('slack-node');
008: var slack = new Slack(SLACK_API_TOKEN);
009:
010: var SlackUtil = {
011:   makeChannelName: (message) => {
012:     return CHANNEL_NAME_PREFIX + message.data.incident.incident_number;
013:   },
014:   createChannelIfNotExists: (channel_name) => {
015:     return new Promise((resolve, reject) => {
016:       slack.api(
017:         'channels.list',
018:         {exclude_archived: 1},
019:         (err, res) => {
020:           if (!err && res.ok) {
021:             if (
022:               !res.channels.some((channel, i, c) => {
023:                 if (channel.name == channel_name) {
024:                   console.log('Channel found. (' + channel_name + ')');
025:                   resolve(channel);
026:                   return true;
027:                 }
028:                 return false;
029:               })
030:             ) {
031:               console.log('Channel not found. (' + channel_name + ')');
032:               resolve(null);
033:             }
034:             return;
035:           }
036:           reject(
037:             new Error(
038:               'Can not get channnel list. ('
039:                 + 'Error: ' + JSON.stringify(res, null, 2)
040:                 + ', Response: ' + JSON.stringify(res, null, 2) + ')'
041:             )
042:           );
043:         }
044:       );
045:     }).then((channel) => {
046:       if (channel) {
047:         return Promise.resolve(channel);
048:       }
049:       return new Promise((resolve, reject) => {
050:         slack.api(
051:           'channels.create',
052:           {name: channel_name},
053:           (err, res) => {
054:             if (!err && res.ok) {
055:               console.log('Channel created. (ID:' + res.channel.id
                                        + ', Name:' + channel_name + ')');
056:               resolve(res.channel);
057:               return;
058:             }
059:             reject(
060:               new Error(
061:                 'Can not create channnel. ('
062:                   + 'Error: ' + JSON.stringify(res, null, 2)
063:                   + ', Response: ' + JSON.stringify(res, null, 2) + ')'
064:               )
065:             );
066:           }
067:         );
068:       });
069:     }).catch((error) => {
070:       console.error(error);
071:     });
072:   },
073:   post: (channel, message) => {
074:     var item = null;
075:     switch (message.type) {
076:       case 'incident.trigger':
077:         item = {
078:           text: '新しいインシデントが発生しました'
079:         }
080:         break;
081:       case 'incident.acknowledge':
082:         item = {
083:           text: '担当者がインシデントを確認しました'
084:         }
085:         break;
086:       case 'incident.resolve':
087:         item = {
088:           text: 'インシデントがクローズされました'
089:         }
090:         break;
091:       default:
092:         console.log('Message ignored, because message type "'
                            + message.type + '" has no need to post.');
093:     }
094:     if (item) {
095:       item.channel = channel;
096:       return new Promise((resolve, reject) => {
097:         slack.api(
098:           'chat.postMessage',
099:           item,
100:           (err, res) => {
101:             if (!err && res.ok) {
102:               console.log('Message posted.');
103:               console.log(JSON.stringify(res, null, 2));
104:               resolve();
105:               return;
106:             }
107:             reject(
108:               new Error(
109:                 'Can not post message. ('
110:                   + 'Error: ' + JSON.stringify(res, null, 2)
111:                   + ', Response: ' + JSON.stringify(res, null, 2) + ')'
112:               )
113:             );
114:           }
115:         );
116:       }).catch((error) => {
117:         console.error(error);
118:       });
119:     }
120:     return Promise.resolve();
121:   },
122:   archiveChannel: (channel_id, channel_name) => {
123:     return new Promise((resolve, reject) => {
124:       slack.api(
125:         'channels.archive',
126:         {channel: channel_id},
127:         (err, res) => {
128:           if (!err && res.ok) {
129:             console.log('Channel archived. (ID:' + channel_id
                                        + ', Name:' + channel_name + ')');
130:             resolve();
131:             return;
132:           }
133:           reject(
134:             new Error(
135:               'Can not archive channel. ('
136:                 + 'Error: ' + JSON.stringify(res, null, 2)
137:                 + ', Response: ' + JSON.stringify(res, null, 2) + ')'
138:             )
139:           );
140:         }
141:       );
142:     }).catch((error) => {
143:       console.error(error);
144:     });
145:   }
146: }
147:
148: exports.handler = (event, context, callback) => {
149:
150:   if (
151:     typeof event.messages !== 'undefined' &&
152:     Array.isArray(event.messages)
153:   ) {
154:
155:     console.log(JSON.stringify(event, null, 2));
156:
157:     var channels = new Map();
158:
159:     console.log('Creating channels...');
160:     Promise.all(
161:       event.messages.map((message, i, m) => {
162:         var channel_name = SlackUtil.makeChannelName(message);
163:         return SlackUtil.createChannelIfNotExists(channel_name);
164:       })
165:     ).then((results) => {
166:       console.log('done.');
167:       results.forEach((channel, i, c) => {
168:         if (channel && !channels.has(channel.name)) {
169:           channels.set(channel.name, channel.id);
170:         }
171:       });
172:       console.log('Posting messages...');
173:       return Promise.all(
174:         event.messages.map((message, i, m) => {
175:           var channel_name = SlackUtil.makeChannelName(message);
176:           if (channels.has(channel_name)) {
177:             return SlackUtil.post(
178:               channels.get(channel_name),
179:               message
180:             );
181:           }
182:           console.warn('Can not post message, because channel "'
                                    + channel_name + '" is not exists.');
183:           return Promise.resolve();
184:         })
185:       );
186:     }).then((results) => {
187:       console.log('done.');
188:       console.log('Archiving channels...');
189:       return Promise.all(
190:         event.messages.map((message, i, m) => {
191:           if (message.type == 'incident.resolve') {
192:             var channel_name = SlackUtil.makeChannelName(message);
193:             if (channels.has(channel_name)) {
194:               return SlackUtil.archiveChannel(
195:                 channels.get(channel_name),
196:                 channel_name
197:               );
198:             }
199:             console.warn('Can not archive channel, because channel "'
                                        + channel_name + '" is not exists.');
200:           }
201:           return Promise.resolve();
202:         })
203:       );
204:     }).then((results) => {
205:       console.log('done.');
206:       callback(null, 'done.');
207:     });
208:
209:   }
210:
211: }

Promise.resolve().then(() => {
    console.log('1');
    return Promise.resolve();
}).then(() => {
    console.log('2');
    return Promise.resolve();
}).then(() => {
    console.log('3');
    return Promise.resolve();
});

Promise.resolve().then(() => {
    console.log('1');
}).then(() => {
    console.log('2');
}).then(() => {
    console.log('3');
});

Promise.resolve().then(() => {
    // ここで job_A を実行する
}).then(() => {
    return Promise.all(
        // ここで並列処理 jobs_B を行うPromiseオブジェクトの配列を生成する
    );
}).then(() => {
    // ここで job_C を実行する
});

Promise.all(
    makeParallelJobs(); // 並列処理したいPromiseオブジェクトの配列を生成する関数
).then(() => {
    console.log('done.');
});

var parallel_jobs = makeParallelJobs();
Promise.all(parallel_jobs).then(() => {
    console.log('done.');
});

Promise.resolve().then(() => {
    // ここで job_A を実行する
}).then(() => {
    return Promise.all(makeParallelJobs());
}).then(() => {
    console.log('done.');
});

var parallel_jobs = makeParallelJobs();
Promise.resolve().then(() => {
    // ここで job_A を実行する
}).then(() => {
    return Promise.all(parallel_jobs);
}).then(() => {
    console.log('done.');
});

2016-04-13T05:08:01.955Z  *  Creating channels...
2016-04-13T05:08:02.185Z  *  Channel not found. (incident_131)
2016-04-13T05:08:02.481Z  *  Channel created. (ID:*********, Name:incident_131)
2016-04-13T05:08:02.482Z  *  done.
2016-04-13T05:08:02.482Z  *  Posting messages...
2016-04-13T05:08:03.205Z  *  Message posted.
2016-04-13T05:08:03.205Z  *  {
  "ok": true,
  "channel": "*********",
  "ts": "1460524083.000003",
  "message": {
    "text": "インシデントがクローズされました",
    "username": "bot",
    "type": "message",
    "subtype": "bot_message",
    "ts": "1460524083.000003"
  }
}
2016-04-13T05:08:03.205Z  *  done.
2016-04-13T05:08:03.205Z  *  Archiving channels...
2016-04-13T05:08:03.450Z  *  Channel archived. (ID:*********, Name:incident_131)
2016-04-13T05:08:03.450Z  *  done.