லாம்டா உருவக்கம் – செயல்முறை

அமேசான் வலைத்தளத்திலிருந்து மூன்று வழிகளில் லாம்டாவை உருவாக்கலாம்.

  1. சொந்தமாக எழுதலாம்.
  2. வடிவச்சிலிருந்து (template) உருவாக்கலாம்.
  3. மறைசேவையகக் களஞ்சியத்திலிருந்து (serverless application repository) பயன்படுத்தலாம்.

சுருக்கமாகவும், எளிமையாகவும் லாம்டா உருவாக்கத்தைப் புரிந்துகொள்வதற்காக, நுண்சேவைக்கான (Microservices) வடிவச்சிலிருந்து ஒரு லாம்டாவை உருவாக்கி, பரிசோதித்துப் பார்க்கலாம்.

நுண்சேவைகள் உருவாக்கத்தில், ஒரு பொருளை உருவாக்குவதும் (Create), பெறுவதும் (Read), இற்றைப்படுத்துவதும் (Update), அழிப்பதும் (Delete) அடிப்படையான தேவையாகும். இதனை ஆங்கிலத்தில் CRUD operation என அழைக்கிறோம். ஒரு HTTP கோரிக்கையை உள்ளீடாக ஏற்று, அக்கோரிக்கையின் வகையைப் பொருத்து, அதன் செயல் என்னவாக இருக்கிறது என்பதை வெளியிடுகிற ஒரு லாம்டாவை இப்பதிவில் உருவாக்கவிருக்கிறோம். லாம்டா என்ன செய்கிறது என்பதைவிட, அதைச் செயல்படுத்துவதற்கு நாம் என்னவெல்லாம் செய்யவேண்டும் என்பதைப் புரிந்துகொள்ளவேண்டும் என்பதற்காக, இந்த எளிய பயன்பாட்டைத் தேர்ந்தெடுத்திருக்கிறேன்.

முதலாவதாக, microservices-http-endpoint என்ற வடிவச்சினைத் தேர்ந்தெடுத்து, கட்டமைக்கவேண்டும். நாம் முந்தைய பதிவில் அறிந்ததுபோல, லாம்டா உருவாக்கத்திற்கு அதன் பெயரும், அதற்கான பொறுப்பையும் வரையறுக்கவேண்டும். எடுத்துகாட்டாக, லாம்டாவிலிருந்து S3யில் ஒரு கோப்பினை அணுகவோ, சேமிக்கவோ வேண்டியிருந்தால், அதற்கான அனுமதிகளுடைய பொறுப்பினை லாம்டாவிற்கு வழங்கவேண்டும். நமது லாம்டாவிற்கு இதுபோன்ற எந்தவொரு தேவையும் இல்லையென்பதால், அதற்கான கொள்கைகளை (policy) தேர்ந்தெடுக்கவேண்டியதில்லை. லாம்டாவுக்கான அடிப்படைத் தேவைகளுக்கேற்ற பொறுப்பு ஒன்று உருவாக்கித் தரப்படும்.

அடுத்ததாக, நமது லாம்டாவின் உள்ளீடு ஒரு HTTP கோரிக்கையாக இருப்பதால், அதை அனுப்புவதற்காக ஒரு API நுழைவாயிலைக் கட்டமைக்கவேண்டும். நமது தேவைக்கு பாதுகாப்பு அமைப்புகள் ஏதும் தேவையில்லையென்பதால், Openஐத் தெரிவுசெய்திருக்கிறோம்.

மேற்சொன்ன தகவல்களைக் கட்டமைத்தவுடன், நமக்கான லாம்டா உருவாக்கப்படுகிறது. நாம் தேர்ந்தெடுத்த வடிவச்சிற்கான வார்ப்புநிரலுடன் அதனைக் கீழேயுள்ள படத்தில் காணலாம்.

நமது தேவைக்கேற்ப, நிரலைக் கீழ்கண்டவாறு மாற்றியமைக்கிறோம்.

exports.handler = (event, context, callback) => {
    const done = (err, res) => callback(null, {
        statusCode: err ? '400' : '200',
        body: err ? err.message : JSON.stringify(res),
        headers: {
            'Content-Type': 'application/json',
        },
    });

    switch (event.httpMethod) {
        case 'DELETE':
            done(null, {action: "deleted"});
            Break;
        case 'GET':
            done(null, {action: "read"});
            Break;
        case 'POST':
            done(null, {action: "created"});
            Break;
        case 'PUT':
            done(null, {action: "updated"});
            Break;
        default:
            done(new Error(`Unsupported method "${event.httpMethod}"`));
    }
};

நிரலை மாற்றியபின் அதனைப் பரிசோதிப்பதற்கு முன்னதாக சேமிக்கவேண்டும். சோதனைக்கென நிகழ்வுகளைக் கட்டமைக்கவேண்டும். Amazon API Gateway AWS Proxy என்ற வடிவச்சிலிருந்து ஒரு புதிய சோதனைநிகழ்வை உருவாக்கலாம்.

இந்நிகழ்வின் பிறமதிப்புகள் நமது லாம்டாவிற்குத் தேவையில்லையென்பதால், httpMethod தவிர பிற மதிப்புகளை அழித்துவிடலாம். ஒவ்வொரு httpMethod க்கும் ஒரு புதிய நிகழ்வினை உருவாக்கிக்கொள்ளலாம்.

இச்சோதனை நிகழ்வுகளை ஒவ்வொன்றாக லாம்டாவிற்கு உள்ளீடாகக்கொடுத்து, அதன் வெளியீட்டினை பின்வரும் படங்களில் காணலாம்.

POST, GET, PUT, DELETE ஆகிய சோதனை நிகழ்வுகளை உள்ளீடாகக்கொடுக்கும்போது கிடைக்கும் வெளியீடுகளைப் பின்வரும் அட்டவணையில் காணலாம்.

Input HTTP Method Output
POST { “action” : “created” }
GET { “action” : “read” }
PUT { “action” : “updated” }
DELETE { “action” : “deleted” }

இவற்றைத்தவிர வேறொரு httpMethodஐ உள்ளீடாகக்கொடுக்கும்போது Unsupported Method என்ற வழுவினை வெளியீடாகப் பெறுகிறோம்.

%d bloggers like this: