Showing posts with label Serverless Computing. Show all posts
Showing posts with label Serverless Computing. Show all posts

Sunday, November 11, 2018

Serverless Computing With AWS Lambda- Part 3

අද article එකෙන් මම කතා කරන්න හදන්නේ Lambda function එකක් හදන්නෙ කොහොමද කියලා...

අද හදන application එකෙන් user inputs ලෙස ID (a String) අරගෙන Widget object එකක් response එකක් විදියට return කරනවා..

පහතින් දැක්වෙන්නේ Widget සදහා වූ source code එකයි.
Widget.java
package com.javaworld.awslambda.widget.model;
public class Widget {
    private String id;
    private String name;
    public Widget() {
    }
    public Widget(String id, String name) {
        this.id = id;
        this.name = name;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
WidgetRequest සදහා වූ source code එක පහතින් දැක්වේ.

WidgetRequest.java
package com.javaworld.awslambda.widget.model;
public class WidgetRequest {
    private String id;
    public WidgetRequest() {
    }
    public WidgetRequest(String id) {
        this.id = id;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
}
ඊලගට අපි lambda request handler එක හදමු. GetWidgetHandler class සදහා වූ source code එක පහතින් දැක්වේ.

GetWidgetHandler.java
package com.javaworld.awslambda.widget.handlers;
import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.javaworld.geekcap.awslambda.widget.model.Widget;
import com.javaworld.geekcap.awslambda.widget.model.WidgetRequest;
public class GetWidgetHandler implements RequestHandler<WidgetRequest, Widget> {
    @Override
    public Widget handleRequest(WidgetRequest widgetRequest, Context context) {
        return new Widget(widgetRequest.getId(), "My Widget " + widgetRequest.getId());
    }
}
GetWidgetHandler class එකෙන් RequestHandler interface එක implement කරලා තියෙනෙවා. එම interface එකෙන් WidgetRequest එක accept කරනවා වගේම return කරන්නේ Widget එකක්.
පහතින් දැක්වෙන්නේ Maven POM file එකේ අන්තර්ගතයයි.. ඉන් JAR file එක හදනවා. එම JAR file එකේ අපේ Lambda function එක අන්තර්ගත වෙනවා.
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.javaworld.geekcap</groupId>
    <artifactId>aws-lambda-java</artifactId>
    <packaging>jar</packaging>
    <version>1.0-SNAPSHOT</version>
    <name>aws-lambda-java</name>
    <url>http://maven.apache.org</url>
    <properties>
<java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    <dependencies>
        <dependency>
            <groupId>com.amazonaws</groupId>
            <artifactId>aws-lambda-java-core</artifactId>
            <version>1.1.0</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
<build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.0.2</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                </configuration>
            </plugin>
            <plugin>
<groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.3</version>
                <configuration>
                    <createDependencyReducedPom>false</createDependencyReducedPom>
                </configuration>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>
මෙම POM file එකේ aws-lambda-java-core dependency එක අන්තර්ගත වෙනවා.  මේක build කරන්න පහත command එක execute කරන්න ඕන වෙනවා.
mvn clean install
මෙම command එක execute කල විට aws-lambda-java-1.0-SNAPSHOT.jar කියල file එකක් ඔයාලගේ target directory එකේ හැදෙනවා. අපි මේ හැදුන file එක තමා AWS Lambda වලට upload කරන්නේ.

හොදයි එහෙනම් මේ හදපු lambda function එක  AWS console එකේ confirm කරන්නේ කියලා අපි ඊලග article එකේදි බලමු.


---ඉෂාරා---


Friday, October 26, 2018

Serverless Computing With AWS Lambda- Part 2


අද අප තවදුරටත් බලමු AWS Lambda පිළිබදව සහ serverless computing පිළිබදව.....

AWS Lambda කියලා කියන්නේ  Amazon වලින් implement කරලා තියෙන serverless computing platform එකක්...  EC2 සහ S3 කියන්නේ ඒ වගේ implement කරලා තියෙන serverless computing platform. AWS Lambda වලින් ඔයාලගේ code එක encrypts කරලා S3 වල ගබඩා කරනවා.ඔයාලා function එකක්  run කරන්න request කලාම, runtime specifications පාවිච්චි කරලා "container" හදනවා. ඉන් පසුව EC2  වල instance එකක එම container deploy කරලා, function එක execute කරනවා....

පහතින් පෙන්වා දෙන්නේ AWS Lambda execute වන process එක.....


(චායාරූප අන්තර්ජාලය ඇසුරිනි)

ඔයාලා Lambda function එකක් create කලාට පසු  runtime environment එක, කොච්චර memory ප්‍රමාණයක් ඕන වෙනවද,  execute කරන method එක වගේ ඒවා  AWS Lambda වල configure කරන්න ඕන වෙනවා.  ඉන් පසුව AWS Lambda මගින් ඔයාලගේ configuration එක container එකක setup කරලා, එම container එක EC2 instance එකක deploy කරනවා.... ඊට පස්සේ ඔයාලා කියපු method එක අනුව execute කිරීම සිදු වෙනවා...


Lambda functions හදන්න මෑතකදී ඉදන් පාවිච්චි කරන්නේ Node, Java, Python කියන languages තමයි... අපි මේ article  එකේදී කතා කරන්නේ java වලින් ලියන්නේ AWS Lambda function කොහොමද කියලා....  AWS Lambda වල run කරන්න code එකක් ලියනකොට අපි ඒක හදුන්වනවා function එකක් කියලා.

AWS Lambda functions in Java

ඔයාලට Lambda functions implement කරන්න පුලුවන් ආකාර 2ක් තියෙනවා.

1. client විසින් ලබා දෙන input stream එක අනුව client වෙත output stream එක ලබා දෙන ආකාරයේ function implement කරන්න පුලුවන්.

2.මෙහිදී predefined interface පාවිච්චි කරන්න පුලුවන්. මේකෙදී වෙන්නේ client විසින් ලබා දෙන input stream එක object එකක් බවට convert වෙලා අදාල function එකට pass කරනවා. ඊට පස්සේ එම function එක execute වෙලා output එක client වෙත ලබා  දෙනවා.

මම දෙවනුව කියපු ක්‍රමය තමා functions implement කරන කොට ගොඩක් ලේසී වෙන්නේ...

Java වලින් කරද්දී මුලින්ම පහත තියෙන AWS Lambda core library එක ඔයාලගේ project එකේ include කර ගන්න ඕන වෙනවා.(සටහන:example uses Maven)

public interface RequestHandler<I, O> {
    /**
     * Handles a Lambda function request
     * @param input The Lambda function input
     * @param context The Lambda execution environment context object.
     * @return The Lambda function output
     */
    public O handleRequest(I input, Context context);
}
ඊලගට  interface implement කරන්න ඕන වෙනවා....
public interface RequestHandler<I, O> {
    /**
     * Handles a Lambda function request
     * @param input The Lambda function input
     * @param context The Lambda execution environment context object.
     * @return The Lambda function output
     */
    public O handleRequest(I input, Context context);
}
 මේ interface එක RequestHandler. එකේ define කරලා තියෙන්නේ එක method එකයි:handleRequest().. මේකෙන් input object එකක් සහ Context object එකක් input stream විදියට pass කරනවා.. ඒ වගේම output එක විදියට object එකක් return කරනවා.
Context object එකෙන් තමයි ඔයාලගේ function එක ගැන information ලබා දෙන්නේ. ඒ වගේම function එක  run වෙන  environment (function එකේ නම, function එකේ memory limit) එක ගැනත් information ලබා දෙනවා.

උදා: ඔයාල Request class සහ Response class එක define කරලා ඔයාලට පුලුවන් පහත අයුරින් lambda function එක implement කරන්න. 
public class MyHandler implements RequestHandler<Request, Response> {
  public Response handleRequest(Request request, Context context) {
    ...
  }
}

දැන් අපි මේ Lambda function ගැන ටිකක් දන්නවනේ..... ඒ නිසා අපි මේ Lambda function implement කරන එක ගැන තවදුරටත් ඊලග articles වලදී කතා කරමු....


---ඉෂාරා---

Tuesday, October 16, 2018

Serverless Computing With AWS Lambda- Part 1





Serverless computing තමා අද වෙන කොට cloud computing වල වැඩියෙන්ම පාවිච්චි වෙන්නෙ…. ඒ නිසා අපි බලමු මොකක්ද මේ serverless architecture කියන්නෙ කියල….

Severless computing වලදි  ඔයාලට ඒ කියන්නෙ developerට server එකක් ඕන වෙන්නෙ නැ … මේ architecture එකේදී ඔයාලගෙ code එක build කරල deploy කරන්න server එකක configure කරන්න ඕන වෙන්නෙත් නැ … ඒ කියන්නෙ ඔයාලගෙ code එක run කරන server එක ඔයාලට manage කරන්න ඕන වෙන්නෙ නෑ. Cloud provider එක තමා server එකක් විදියට වැඩ කරන්නේ …. AWS Lambda කියන්නෙ ඒ වගේ serverless computing platform එකක්.

අපි දැන් බලමු මොකක්ද serverless එකක් execute වෙන model එක කියලා….

(චායාරූප අන්තර්ජාලය ඇසුරිනි)

  1. මුලින්ම කරන්නේ තමන්ට ඕන කරන function එක execute කරන්න  serverless computing platform එකකට client විසින් request එකක්  දැමීමයි.
  2. Serverless computing platform එකෙන් check කරල බලනවා මේ වෙනකොටම අදාළ function එක එහි මොකක් හරි server එකක් උඩ run වෙනවද කියල… එහෙම run වෙනවා නම් අදාළ function එක data store එකෙන් platform එකට load කරනවා.
  3. ඊට පස්සෙ platform එක function එක එහි කුමක් හෝ server එකකට (කලින් configure කරලා තියෙන්න ඕන ඒ function එක එම environment එකේ execute වෙනවා කියලා) deploy කරනවා.
  4. Platform එකෙන් function එක execute කරලා result එක ලබා ගන්නවා.
  5. ලබා ගත් result එක clientට දෙනවා.

සමහර වෙලාවට serverless computing වලට FAAS (Function As A Service) කියලා කියනවා. මොකද ඔයාල මේකේ ඔයාලගෙ code එක build කරන්නේ function එකක් විදියට නිසයි….
මේ Platform එකෙන් ඔයාලගෙ function එක එයාලගේම server එකක execute කරලා, request එක සහ response එක අතර සම්බන්ධතාවක් තියා ගන්නවා.

Serverless computing වල use කරන වෙලාව අනුව මුදල් අය කිරීම සිදු කරනවා. වෙලාව ගණනය කරන්නේ code එක execute කරන්න පටන් අරන් result එක ලබා ගන්න ගත වුණු කාල පරාසයයි…

Serverless computing පිළිබඳව කතා කරනකොට වැදගත් වන කරුණු 3ක් තියෙනවා. ඒ තමයි nanoservices architecture, scalability සහ price කියල කියන්නෙ.
nanoservices architecture කියන්නෙ ඔයාලගෙ code එක පොඩි පොඩි කොටස් වලට බෙදලා ඒ එක එක කොටස් වල test කරන එකටයි. මේ නිසා code එකේ තියෙන side effects අඩු කර ගන්න පුළුවන්.
Pricing කියලා කියන්නෙ කලින් කිව්වා වගේ මුදල් ගෙවන්න වෙන එකටයි. මේ ගෙවන මුදල් ප්‍ර්‍රමාණය සමානුපාතික වෙනවා ඔයගෙ usage එකට.
Scalability කියලා කියන්නෙ serverless computing වලට තියෙන infinite scale එකයි. Serverless එක්ක වැඩ කරන කොට, ඔයාලට කියන්න තියෙන්නෙ එකම වෙලාවෙ සිදු වෙන function මොනවාද කියලා. එතකොට Platform එක විසින්ම scalability සාදා ගන්නවා. ඔයාල කරන request ප්‍රමාණය මත සාදා ගත යුතු containers ගණන වෙනස් වෙනවා.

Severless වල ප්‍රධාන සoකල්ප 5ක් තියෙනවා. ඒ තමයි,
1. Functions
2. Events
3. Resources
4. Services
5. Plugins

Node.js, Python, Java, C# වගේ languages මේ serverless framework එකේ functions ලියන්න use කරනවා.

හොදයි අපි තව දුරටත් මේ serverless computing  පිළිබඳව ඊළඟ articles වලදී කතා කරමු….

---ඉෂාරා---