Question

我正在研究一个lambda函数，它将通过amazon rest api触发。

我创建了以下

REST API控制台上的POST端点
链接到REST API的lambda函数

现在作为第一次尝试，我创建了这个函数，它将接受param为

{
 "userProfileImagePath":"facebook users profile image path via GET /{user-id}/picture"
}

lambda函数将使用request模块获取图像，然后上传到存储桶。

由于我使用了多个模块，因此我在本地创建了所有内容并将其压缩，包括node_modules，并通过指定Handler名称将它们上传到lambda函数控制台。

到目前为止，它很好并且效果很好。

现在为了扩展这一点，我试图发送2张个人资料图片 - 一个来自用户 - 另一个是他/她的朋友之一 - 将两个图像合并为一个，然后将合并的图像上传到目标文件。

我尝试了不同的合并方法，没有任何效果。在这里找到了一些解决方案，看起来他们真的不喜欢流

这是我到目前为止所做的事情，正如我所提到的那样，这两个图像都被上传到了一个桶，但合并似乎失败了，我没想到要完成这个，如果你能给我一些指示，那将会非常有帮助如何做到这一点。

目前，它使用异步模块执行单个任务

首先将图像并行上传到s3
然后使用s3.getObject并行下载它们
最后完成第二个任务尝试合并并推回到s3

基本上会有一个模板图像，在模板图像上会放置（合并）多个图像，在下面的代码中，我正在考虑将userProfileImagePath作为主模板并尝试将另一个图像合并到其中。

如果有不同的方法，请告诉我。

这是我到目前为止所做的事情

/**
* This is a test script which runs as a lambda function on amazon 
* The lamda function is linked with an amazon end point
* The script will accept a image url (facebook/gravator) etc and will upload to a destination s3 bucket and returns the url 
* The param looks like 
{
    "userProfileImagePath":"https://fbcdn-profile-a.......",
    "friendProfileImagePath":"https://fbcdn-profile-a......."
}
*/

var exec = require('child_process').exec,
    async = require('async'),
    request = require('request'),
    gm = require('gm'),
    imageMagick = gm.subClass({ imageMagick: true }),
    aws = require('aws-sdk');

exports.handler = function(req, context) {
    var errMsg = '',
        userProfileImageName = 'user_profile',
        friendProfileImageName = 'friend_profile',
        mergedImageName = 'final_image',
        destinationBucket = 'destination_bucket',
        response = {} ,
        s3 = new aws.S3();

    if (req.userProfileImagePath === '') {
        errMsg = 'Missing the userProfileImage';
    }

    if (req.friendProfileImagePath === '') {
        errMsg = 'Missing the friendProfileImagePath ';
    }

    if (errMsg === '') {
        async.auto({
            copyUserImageToS3 : function(autoCallback) {
                console.log('MyImage :'+req.userProfileImagePath);
                //var myImageData = {} ;
                request({
                    url: req.userProfileImagePath,
                    encoding: null
                }, function(err, res, body) {
                    if (err) { return autoCallback(err); }

                    s3.putObject({
                        Bucket: destinationBucket,
                        Key: userProfileImageName+'.jpg',
                        ContentType: res.headers['content-type'],
                        ContentLength: res.headers['content-length'],
                        Body: body, // buffer
                        ACL:'public-read'
                    }, autoCallback); 
                });
            },

            copyFriendImageToS3 : function(autoCallback) {
                console.log('FriendImage :'+req.friendProfileImagePath);
                //var friendImageData = {} ;
                request({
                    url: req.friendProfileImagePath,
                    encoding: null
                }, function(err, res, body) {
                    if (err) { return autoCallback(err); }  

                    s3.putObject({
                        Bucket: destinationBucket,
                        Key: friendProfileImageName+'.jpg',
                        ContentType: res.headers['content-type'],
                        ContentLength: res.headers['content-length'],
                        Body: body, // buffer
                        ACL:'public-read'
                    }, autoCallback);
               });
            },

            getUserImageFromS3 : ['copyUserImageToS3', function(autoCallback,results) {
                    s3.getObject({
                    Bucket: destinationBucket,
                    Key: userProfileImageName+'.jpg',
                }, autoCallback);
            }],

            getFriendImageFromS3 : ['copyFriendImageToS3', function(autoCallback,results) {
                    s3.getObject({
                    Bucket: destinationBucket,
                    Key: friendProfileImageName+'.jpg',
                }, autoCallback);
            }],

            mergeImages : ['getUserImageFromS3','getFriendImageFromS3', function(autoCallback,results) {
                console.log('Here');
                gm()
                .in('-page', '+0+0')  // Custom place for each of the images
                .in(results.getUserImageFromS3.body)
                .in('-page', '+100+100')
                .in(results.getFriendImageFromS3.body)
                .minify()  
                .mosaic()  
                .toBuffer('JPG', function (err, buffer) {
                        if (err) { return autoCallback(err); }
                        s3.putObject({
                        Bucket: destinationBucket,
                        Key: mergedImageName+'.jpg',
                        ContentType:  results.getUserImageFromS3.headers['content-type'],
                        ContentLength: results.getUserImageFromS3.headers['content-length'],
                        Body: buffer, // buffer
                        ACL:'public-read'
                    }, autoCallback);
                });
            }],
        },
        function(err, results) {
            if (err) {
                response = {
                    "stat":"error",
                    "msg":"Error manipulating the image :: "+err 
                } ;
                context.done(null,response);
            } else {
                response = {
                    "stat":"ok",
                    "imageUrl":"https://s3-................../"+mergedImageName+".jpg"
                } ;
                context.done(null,response);
            }
        });
    } else {
        response = {
            "stat":"error",
            "msg": errMsg
        } ;
        context.done(null,response);
    }
};

更新

我尝试让代码在执行一些更改后在本地运行，并使用文件系统进行操作，它似乎正在工作，不知道如何使用s3在lamba上使其工作相同这是本地使用文件系统的工作代码

/**
* This will download both the images locally and then merge them 
* We can merge multiple images as we need on a base template specifiying the position as shown in the code
* need to make sure that the graphicsmagick is inatalled 
* sudo apt-get install graphicsmagick
*/
var exec = require('child_process').exec,
    async = require('async'),
    request = require('request'),
    fs = require('fs'),
    gm = require('gm'),
    imageMagick = gm.subClass({ imageMagick: true }),
    userProfileImagePath ='https://fbcdn-profile-a.akamaihd.net...',
    friendProfileImagePath ='https://fbcdn-profile-a.akamaihd.net..';


exports.mergeFile = function(req, context) {
    var errMsg = '',
        userProfileImageName = 'user_profile',
        friendProfileImageName = 'friend_profile',
        mergedImageName = 'final_image',
        destinationBucket = 'testimagemanipulator',
        response = {} ;

    if (errMsg === '') {
        async.auto({
            copyUserImage : function(autoCallback) {
                request({
                    url: userProfileImagePath,
                    encoding: null
                }, function(err, res, body) {
                    if (err) { return autoCallback(err); }

                    fs.writeFile(__dirname +'/public/images/'+userProfileImageName+'.jpg', body, 'binary', function(err) {
                        if(err) { return autoCallback(err); }

                        return autoCallback();
                    }); 
                });
            },

            copyFriendImage : function(autoCallback) {
                request({
                    url: friendProfileImagePath,
                    encoding: null
                }, function(err, res, body) {
                    if (err) { return autoCallback(err); }  

                    fs.writeFile(__dirname +'/public/images/'+friendProfileImageName+'.jpg', body, 'binary', function(err) {
                        if(err) { return autoCallback(err); }

                        return autoCallback();
                    });
                });
            },

            mergeImages : ['copyUserImage','copyFriendImage', function(autoCallback,results) {
                console.log('Here');
                gm()
                .in('-page', '+0+0')  // Custom place for each of the images
                .in(__dirname +'/public/images/'+userProfileImageName+'.jpg')
                .in('-page', '+140+50')
                .in(__dirname +'/public/images/'+friendProfileImageName+'.jpg')
                .minify()  // Halves the size, 512x512 -> 256x256
                .mosaic()  // Merges the images as a matrix
                .write(__dirname +'/public/images/'+mergedImageName+'.jpg', function (err) {
                        if (err) { return autoCallback(err); }

                        fs.unlink(__dirname +'/public/images/'+userProfileImageName+'.jpg');
                        fs.unlink(__dirname +'/public/images/'+friendProfileImageName+'.jpg');
                        return autoCallback() ;
                });
            }],
        },
        function(err, results) {
            if (err) {
                response = {
                    "stat":"error",
                    "msg":"Error manipulating the image :: "+err 
                } ;
                console.log(response) ;
            } else {
                response = {
                    "stat":"ok",
                    "imageUrl":__dirname +'/public/images/'+mergedImageName+'.jpg'
                } ;
                console.log(response) ;
            }
        });
    } else {
        response = {
            "stat":"error",
            "msg": errMsg
        } ;
        console.log(response) ;
    }
};

module.exports.mergeFile() ;

Answer 1

好的看起来很难实现我所看到的内容，如上面的问题所解释的那样。然而，经过几次尝试和不同的模块后，没有尝试过。正如所解释的那样，lambda函数的目的是

获取公共图片网址（facebook）
下载并合并在一起，它也可以合并到图像模板上
将一些文字写入合并的图像。

到目前为止，最好的图像处理模块是gm，这可以在aws lambda上使用，我们需要确保它是Image Magic的子类

接下来是合并操作可以通过使用aws /tmp文件夹来完成，其中图像可以暂时放置，合并完成后可以从那里删除。

这是一个工作的lambda脚本，它链接到aws REST API

/**
* This is a test script which runs as a lambda function on amazon 
* The lamda function is linked with an amazon end point
* The script will accept a image url (facebook/gravator) etc and will upload to a destination s3 bucket and returns the url 
* The param looks like 
{
    "userProfileImagePath":"https://fbcdn-profile-a.akamaihd.net/....",
    "friendProfileImagePath":"https://fbcdn-profile-a.akamaihd.net/...."
}
*/

var exec = require('child_process').exec,
    async = require('async'),
    request = require('request'),
    gm = require('gm').subClass({ imageMagick: true }),
    fs = require('fs'),
    aws = require('aws-sdk');

exports.handler = function(req, context) {
    var errMsg = '',
        userProfileImageName = 'user_profile',
        friendProfileImageName = 'friend_profile',
        mergedImageName = 'final_image',
        destinationBucket = 'mybucket',
        response = {} ,
        s3 = new aws.S3();

    if (req.userProfileImagePath === '') {
        errMsg = 'Missing the userProfileImage';
    }

    if (req.friendProfileImagePath === '') {
        errMsg = 'Missing the friendProfileImagePath ';
    }

    if (errMsg === '') {
        async.auto({
            copyUserImage : function(autoCallback) {
                request({
                    url: req.userProfileImagePath,
                    encoding: null
                }, function(err, res, body) {
                    if (err) { return autoCallback(err); }

                    fs.writeFile('/tmp/'+userProfileImageName+'.jpg', body, 'binary', function(err) {
                        if(err) { return autoCallback(err); }

                        return autoCallback();
                    }); 
                });
            },

            copyFriendImage : function(autoCallback) {
                request({
                    url: req.friendProfileImagePath,
                    encoding: null
                }, function(err, res, body) {
                    if (err) { return autoCallback(err); }  

                    fs.writeFile('/tmp/'+friendProfileImageName+'.jpg', body, 'binary', function(err) {
                        if(err) { return autoCallback(err); }

                        return autoCallback();
                    });
                });
            },

            mergeImages : ['copyUserImage','copyFriendImage', function(autoCallback,results) {
                var bgImage = '/tmp/'+userProfileImageName+'.jpg',
                    frontImage = '/tmp/'+friendProfileImageName+'.jpg';

                gm()
                .in('-page', '+0+0')  // Custom place for each of the images
                .in(bgImage)
                .in('-page', '+140+50')
                .in(frontImage)
                .mosaic()  // Merges the images as a matrix
                .font("Arial")
                .fontSize(50)
                .fill('black')
                .drawText(1, 1, 'Hello World', 'Center')
                .fill('blue')
                .drawText(0, 0, 'Hello World', 'Center')
                .write('/tmp/'+mergedImageName+'.jpg', function (err) {
                        if (err) { return autoCallback(err); }

                        var stream = fs.createReadStream('/tmp/'+mergedImageName+'.jpg');
                        var stats = fs.statSync('/tmp/'+mergedImageName+'.jpg');
                        console.log('Merged File size :'+stats['size']);
                        s3.upload({
                            Bucket: destinationBucket,
                            Key: mergedImageName+'.jpg',
                            ContentType: 'image/jpeg',
                            ContentLength: stats['size'],
                            Body: stream, // buffer
                            ACL:'public-read'
                    }, autoCallback);   
                });
            }],
        },
        function(err, results) {
            if (err) {
                response = {
                    "stat":"error",
                    "msg":"Error manipulating the image :: "+err 
                } ;
                context.done(null,response);
            } else {
                response = {
                    "stat":"ok",
                    "imageUrl":"https://domain.amazonaws.com/mybucket/"+mergedImageName+".jpg"
                } ;
                context.done(null,response);
            }
        });
    } else {
        response = {
            "stat":"error",
            "msg": errMsg
        } ;
        context.done(null,response);
    }
};

Amazon Lambda函数合并多个s3图像并放入目标存储桶

1 个答案: