Sign in Subscribe
By Thisara Priyamal in Spring Boot —

AWS IAM සහ API Gateway සමග Spring Boot API ආරක්ෂා කරමු - SC Guide

AWS IAM සහ API Gateway සමග Spring Boot API ආරක්ෂා කරමු - SC Guide

ආරම්භයක්: ඔබේ API එකට ආරක්ෂාවක්! (Introduction: Securing Your API!)

ආයුබෝවන් යාළුවනේ! අද අපි කතා කරන්න යන්නේ ගොඩක් දෙනෙක්ට තියෙන පොදු ප්‍රශ්නයක් ගැන – ඒ තමයි, අපි හදන Spring Boot API එකක් කොහොමද ආරක්ෂිතව පවත්වාගෙන යන්නේ කියන එක. විශේෂයෙන්ම, AWS Cloud එක ඇතුළේ වැඩ කරන කොට, අපිට තියෙන ප්‍රබලම මෙවලම් දෙකක් තමයි AWS API Gateway සහ AWS IAM (Identity and Access Management). මේ දෙක එකතු කරලා, අපේ Spring Boot API එකට හොඳ ආරක්ෂාවක් සපයන්නේ කොහොමද කියලා අපි අද පියවරෙන් පියවර බලමු.

අපි දන්නවා, API එකක් කියන්නේ අපේ Application එකේ හදවත වගේ. ඒකට හැමෝටම ඕන විදියට Access වෙන්න දුන්නොත්, Security Holes ගොඩක් ඇති වෙන්න පුළුවන්. ඒ නිසා, API Gateway එක හරහා එන Request වලට, ඒ Request එක යවන්නේ කවුද, එයාට මොනවද කරන්න පුළුවන් කියලා තීරණය කරන්න IAM භාවිතා කරන එක ගොඩක් වැදගත්. මේක විශේෂයෙන්ම Microservices Architecture එකකදී, Services අතරේ ආරක්ෂිතව සන්නිවේදනය කරන්න අවශ්‍ය වෙනවා.

මේ ලිපියෙන්, අපි මුලින්ම Spring Boot API එකක් හදනවා. ඊට පස්සේ, ඒක API Gateway එකට සම්බන්ධ කරලා, IAM Authorizer එකක් හරහා ඒක ආරක්ෂා කරන ආකාරය විස්තර කරනවා. අන්තිමට, ඒ ආරක්ෂිත API එකට Access කරන්නේ කොහොමද කියලත් බලමු. එහෙනම්, අපි පටන් ගමු!

1. API Gateway සහ IAM: ආරක්ෂාවට අත්වැලක් (API Gateway and IAM: A Helping Hand for Security)

AWS API Gateway කියන්නේ අපේ Backend Services වලට එන සියලුම API Calls වලට පිවිසුම් දොරටුව (Entry Point) වගේ දෙයක්. මේකෙන් අපිට Traffic Management, Caching, Throttling, Monitoring වගේ දේවල් කරන්න පුළුවන්. ඒ වගේම, අපිට Security Layer එකක් දාන්නත් මේක ගොඩක් ප්‍රයෝජනවත් වෙනවා.

AWS IAM කියන්නේ AWS Cloud එකේ Resources වලට Access Control කරන්න තියෙන Service එක. අපිට Users, Groups, Roles හදලා, ඒ අයට විවිධ Permissions දෙන්න පුළුවන්. උදාහරණයක් විදියට, කෙනෙක්ට S3 Bucket එකක Objects කියවන්න විතරක් පුළුවන් වෙන්න හදන්න පුළුවන්, තව කෙනෙක්ට ඒකේ Objects Upload කරන්නත් පුළුවන් වෙන්න හදන්න පුළුවන්.

මේ දෙක එකතු කරලා, API Gateway එකේදී අපි IAM Authorization භාවිතා කරනවා. ඒ කියන්නේ, අපේ API එකට එන හැම Request එකක්ම, AWS Credentials (Access Key ID, Secret Access Key) වලින් SigV4 (Signature Version 4) කියන ක්‍රමයට අත්සන් කරලා (signed) තියෙන්න ඕනේ. API Gateway එක මේ Signature එක validate කරනවා. Validate වුණොත් විතරයි Request එක අපේ Backend Spring Boot API එකට යවන්නේ. මේකෙන් වෙන්නේ මොකක්ද? අපේ API එකට Access කරන්න පුළුවන් වෙන්නේ අපිට ඕන කරන IAM Users, Roles හෝ Federated Users ලට විතරයි.

2. සූදානම් වෙමු: අවශ්‍ය දේවල් (Let's Get Ready: Prerequisites)

මේ Tutorial එකට අපිට මේ දේවල් අවශ්‍ය වෙනවා:

  • AWS Account එකක්: හැමදේම කරගන්න පුළුවන් Account එකක් හෝ අවශ්‍ය Permissions තියෙන IAM User කෙනෙක්.
  • Java Development Kit (JDK): Version 8 හෝ ඊට ඉහළ.
  • Apache Maven හෝ Gradle: Spring Boot Project එක Build කරන්න.
  • IDE එකක්: IntelliJ IDEA, VS Code වගේ එකක්.
  • Basic knowledge of Spring Boot, AWS Console, IAM, API Gateway.
  • AWS CLI (Optional but Recommended): API Access කරන්න. Python boto3 knowledge එකක් තියෙනවා නම් ගොඩක් හොඳයි.

3. සරල Spring Boot API එකක් හදමු (Let's Create a Simple Spring Boot API)

මුලින්ම, අපි ඉතාම සරල Spring Boot REST API එකක් හදමු. මේ API එකේ කිසිම Security Logic එකක් අපි දාන්නේ නෑ. මොකද, Security Layer එක සම්පූර්ණයෙන්ම API Gateway එකෙන් Handle කරන නිසා.

ඔබට Spring Initializr භාවිතා කරලා අලුත් Project එකක් හදන්න පුළුවන්. Dependencies විදියට Spring Web තෝරගන්න.

Project එක හැදුවාට පස්සේ, පහත `HelloController.java` වගේ Class එකක් හදන්න:

package com.example.iamapigatewaydemo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String sayHello() {
        return "Hello from Spring Boot! Your request was authorized by AWS IAM!";
    }
}

මේ Controller එක `GET /hello` කියන Endpoint එකට Call එකක් ආවම Simple String එකක් Return කරනවා. දැන් මේ Project එක Run කරලා බලන්න. ඒක `http://localhost:8080/hello` වගේ Address එකකින් වැඩ කරනවා ඇති.

4. API Gateway එක සකසමු: IAM Authorizer එකක් සමග (Setting up API Gateway: With IAM Authorizer)

දැන් අපි මේ Spring Boot API එක API Gateway එකට සම්බන්ධ කරලා, IAM Authorization දාමු. මේක පියවරෙන් පියවර කරමු.

4.1. REST API එකක් සාදා ගැනීම (Creating a REST API)

  1. AWS Management Console එකට Log වෙලා, API Gateway Service එකට යන්න.
  2. `Create API` button එක Click කරන්න.
  3. `REST API` (non-proxy) යටතේ `Build` Click කරන්න.
  4. `Choose the protocol` යටතේ `New API` තෝරලා, `API name` එකට `SpringBootIamApi` වගේ නමක් දෙන්න. `Endpoint Type` එකට `Regional` තෝරලා `Create API` කරන්න.

4.2. Resource සහ Method නිර්මාණය (Creating Resource and Method)

  1. අපි හදපු `SpringBootIamApi` එක තෝරගන්න.
  2. වම් පැත්තේ Navigation Bar එකේ `Resources` යටතේ, `Actions` Dropdown එකෙන් `Create Resource` තෝරන්න.
  3. `Resource Name` එකට `hello` කියලා දීලා, `Create Resource` කරන්න. (Path එක `/hello` වෙන්න ඕනේ).
  4. අලුතින් හදපු `/hello` Resource එක තෝරගෙන, `Actions` Dropdown එකෙන් `Create Method` තෝරන්න.
  5. Method Type එකට `GET` තෝරලා, Right mark එක Click කරන්න.

4.3. IAM Authorization සක්‍රීය කිරීම (Enabling IAM Authorization)

මේක තමයි වැදගත්ම පියවර! `GET` Method එකේ Setup Page එකේ (Method Execution screen එකේ), `Method Request` Section එක තෝරන්න.

  1. `Authorization` වලට යාබදව තියෙන Pencil icon එක Click කරන්න.
  2. Drop-down list එකෙන් AWS_IAM තෝරලා, Check mark එක Click කරන්න.

දැන් මේ Method එකට එන හැම Request එකක්ම IAM Credentials වලින් SigV4 අත්සන් කරලා තියෙන්න ඕනේ.

4.4. Integration Type එක සකසමු (Setting the Integration Type)

දැන් අපි API Gateway එක අපේ Spring Boot Backend එකට සම්බන්ධ කරමු. `Method Execution` screen එකේම, `Integration Request` Section එක තෝරන්න.

  1. `Integration type` එක `HTTP` විදියට තෝරන්න.
  2. `Endpoint URL` එකට, ඔබේ Spring Boot API එක Run වෙන URL එක දෙන්න. (උදා: `http://your-public-ip:8080/hello` හෝ `http://your-ec2-dns:8080/hello`).
  3. `Use Proxy Integration` කියන Option එක Check කරන්න (මේකෙන් Client එකේ Request Header, Query Parameters, Body ඒ විදියටම Backend එකට යවනවා).
  4. `Save` කරන්න.

දැන් API Gateway එක Ready. හැබැයි, වෙනස්කම් Apply වෙන්න නම්, අපි API එක Deploy කරන්න ඕනේ.

  1. `Actions` Dropdown එකෙන් `Deploy API` තෝරන්න.
  2. `Deployment stage` එකට `[New Stage]` තෝරලා, `Stage name` එකට `dev` වගේ නමක් දීලා `Deploy` කරන්න.

Deploy වුණාට පස්සේ ඔබට Invoke URL එකක් ලැබෙයි. මේක තමයි අපේ API Gateway Endpoint එක. මේක Save කරගන්න. (උදා: `https://xxxxxxx.execute-api.us-east-1.amazonaws.com/dev/hello`)

5. Spring Boot API එක Deploy කරමු (Deploying the Spring Boot API)

අපේ Spring Boot API එක දැන් API Gateway එකට සම්බන්ධ කරලා තියෙන්නේ. හැබැයි, API Gateway එකට අපේ Spring Boot API එකට Access කරන්න පුළුවන් වෙන්න ඕනේ. ඒ කියන්නේ, අපේ Spring Boot App එක Publicly Accessible වෙන්න ඕනේ (අවම වශයෙන් API Gateway එකට හෝ). මේකට විවිධ ක්‍රම තියෙනවා:

  • EC2 Instance එකක Deploy කිරීම: EC2 Instance එකක් හදලා, Spring Boot JAR එක Deploy කරලා, Security Group එකෙන් Port 8080 (හෝ ඔබ පාවිච්චි කරන Port එක) Publically Allow කරන්න.
  • AWS Elastic Beanstalk: මේකෙන් Spring Boot App එක Deploy කරන එක පහසුයි.
  • Local Computer එකක Run කරලා Ngrok වගේ Tunneling Tool එකක් පාවිච්චි කිරීම: Development/Testing වලට මේක ප්‍රයෝජනවත්.

ඔබට කැමති ක්‍රමයක් භාවිතා කරන්න පුළුවන්. වැදගත් වන්නේ, API Gateway එකට ඔබ ලබා දුන් Endpoint URL එකට පිවිසෙන්න හැකි වීමයි.

6. API එකට SigV4 Signature එකක් එක් කර Access කරමු (Accessing the API with a SigV4 Signature)

දැන් තමයි වැඩේ තියෙන්නේ! අපි IAM Authorization දැම්ම නිසා, අපේ API Gateway Endpoint එකට සාමාන්‍යයෙන් Call කරන්න බෑ. `Unauthorized` Error එකක් එයි. අපි ඒ වෙනුවට SigV4 Signed Request එකක් යවන්න ඕනේ.

මේකට පහසුම ක්‍රමය තමයි AWS SDK එකක් භාවිතා කිරීම. අපි Python වල boto3 භාවිතා කරලා මේක කරන්නේ කොහොමද කියලා බලමු. මේකට ඔබට boto3 Install කරගන්න වෙනවා: pip install boto3.

ඔබට අවශ්‍ය AWS Credentials (Access Key ID, Secret Access Key) ඔබේ ~/.aws/credentials file එකේ හෝ Environment Variables විදියට Set කරලා තියෙන්න ඕනේ. (Production එකේදී IAM Roles භාවිතා කරන්න). මේ Credential වලට, අපි හදපු API Gateway Resource එකට `execute-api:Invoke` Permission එක තියෙන්න ඕනේ. (උදා: `arn:aws:execute-api:REGION:ACCOUNT_ID:API_ID/STAGE/GET/hello`).

import boto3
import json

# Replace with your API Gateway Invoke URL
# ඔබගේ API Gateway Invoke URL එක මෙතනට දාන්න
API_GATEWAY_URL = "https://xxxxxxx.execute-api.us-east-1.amazonaws.com/dev/hello"
REGION = "us-east-1" # ඔබගේ API Gateway Region එක

def call_iam_authorized_api():
    # Create an API Gateway client using boto3
    # boto3 භාවිතා කරලා API Gateway client එකක් හදමු
    client = boto3.client("execute-api", region_name=REGION)

    try:
        # Invoke the API Gateway endpoint with IAM authorization
        # IAM authorization එකත් එක්ක API Gateway endpoint එකට Call කරමු
        response = client.invoke(
            restApiId=API_GATEWAY_URL.split('/')[2].split('.')[0], # Extract API ID
            stageName=API_GATEWAY_URL.split('/')[3], # Extract Stage Name
            httpMethod="GET",
            path="/hello",
            # body=b"{}" # For POST/PUT requests, include a body
        )

        # Read the response payload
        # Response එක කියවමු
        response_payload = response["payload"].read().decode("utf-8")
        print("API Response:", response_payload)

    except Exception as e:
        print(f"Error calling API: {e}")

if __name__ == "__main__":
    call_iam_authorized_api()

මේ Python Code එක Run කළාම, `boto3` Library එක විසින්ම SigV4 Signature එක හදලා, Request එකට එකතු කරලා API Gateway එකට යවනවා. API Gateway එක මේ Signature එක Validated කළාම, Request එක අපේ Spring Boot API එකට යවනවා. සාර්ථක නම්, ඔබට Spring Boot API එකෙන් එන Response එක දකින්න පුළුවන් වෙයි.

මේ වගේම වෙනත් AWS SDKs (Java, Node.js, .NET etc.) භාවිතා කරලත් ඔබට SigV4 Signed Requests හදන්න පුළුවන්. Postman වගේ Tools වලටත් SigV4 Signing Support එක තියෙනවා.

නිගමනය (Conclusion)

අද අපි Spring Boot API එකක් AWS API Gateway සහ IAM භාවිතා කරලා ආරක්ෂිතව පවත්වාගෙන යන ආකාරය ගැන ඉගෙන ගත්තා. මේ ක්‍රමය ගොඩක් ආරක්ෂිතයි, මොකද API එකට Access කරන්න පුළුවන් වෙන්නේ වලංගු AWS Credentials තියෙන කෙනෙක්ට විතරයි. ඒ වගේම, AWS IAM එකේ තියෙන Fine-grained Access Control හැකියාව නිසා, අපිට කාට මොනවද කරන්න පුළුවන් කියලා ඉතාම නිවැරදිව තීරණය කරන්නත් පුළුවන්.

ඔබේ Microservices වල හෝ වෙනත් Security-sensitive APIs වලදී මේ ක්‍රමය පාවිච්චි කරන එක ගොඩක් වටිනවා. මේකෙන් ඔබේ Application එකේ Overall Security Posture එක ගොඩක් දියුණු වෙනවා.

මේ ලිපිය ප්‍රයෝජනවත් වෙන්න ඇති කියලා හිතනවා. ඔබට ප්‍රශ්න තියෙනවා නම්, පහත Comment Section එකේ දාන්න. අපි ඊළඟ ලිපියකින් හමුවෙමු! Happy Coding!

ඔබට මේ Tutorial එක ගැන අදහස් තියෙනවාද? නැත්නම් මේ වගේම වෙනත් මාතෘකාවක් ගැන දැනගන්න කැමතිද? පහලින් Comment කරන්න!

Previous

Java RESTful Web Services Tutorial | JAX-RS Sinhala Guide | REST Principles in Java

 Next

JavaScript `let` vs `var` වෙනස - SC Guide

You might also like...