Sign in Subscribe
By Thisara Priyamal in Keycloak —

Keycloak සහ Spring Boot එකට සෙට් කරමු - Security SC Guide

Keycloak සහ Spring Boot එකට සෙට් කරමු - Security SC Guide

Keycloak සහ Spring Boot එකට සෙට් කරමු: Security Basics SC Guide

හලෝ කොම්පියුටර් ගේම්ස් ගහන, කෝඩ් ලියන අපේ යාළුවෝ හැමෝටම! 🎮💻 මේ දවස්වල අලුත් technologies ගැන ඉගෙන ගන්න ආස, ඒ වගේම අපේ Applications වල Security එක තවත් ශක්තිමත් කරන්න හිතන් ඉන්න හැමෝටම මේ Article එක ගොඩක් වැදගත් වෙයි. අද අපි කතා කරන්න යන්නේ මේ දවස්වල හුඟක් කතාබහට ලක්වෙන, ඒ වගේම Identity and Access Management (IAM) වලට සුපිරිම Solution එකක් ගැන – ඒ තමයි Keycloak!

විශේෂයෙන්ම Spring Boot එක්ක වැඩ කරන කට්ටියට මේක අත්‍යවශ්‍යයි කිව්වොත් වැරදි නෑ. මොකද Keycloak අපිට උදව් කරනවා අපේ Users ලා Manage කරන්න, Roles දෙන්න, Single Sign-On (SSO) වගේ දේවල් කරන්න, ඒ හැමදේම Security එකට හානියක් නැතිව. එහෙනම්, අපි බලමු Keycloak කියන්නේ මොකක්ද, ඒක කොහොමද Spring Boot Application එකකට සෙට් කරගන්නේ කියලා!

1. Keycloak කියන්නේ මොකක්ද මේ මචං? 🧐

සරලව කිව්වොත් Keycloak කියන්නේ Open Source Identity and Access Management (IAM) Solution එකක්. අපේ Applications වලට Users ලා Authenticate කරන්න (login කරවන්න) සහ Authorize කරන්න (ඒ අයට මොනවද කරන්න පුළුවන් කියලා තීරණය කරන්න) මේකෙන් ලොකු උදව්වක් ලැබෙනවා.

සාමාන්‍යයෙන් අපිට User Authentication සහ Authorization Logic එක හැම Application එකකම වෙන වෙනම ලියන්න වෙනවා. ඒක හුඟක් වෙලාවට වෙහෙසකර, වැරදි වෙන්න පුළුවන්, වගේම Security Risks වැඩි වැඩක්. Keycloak වගේ IAM Solution එකක් තිබ්බම මේ හැමදේම එක තැනකින් Manage කරන්න පුළුවන්. ඒක හරියට Security Gate එකක් වගේ. කවුද ඇතුළට එන්නේ, කවුද මොනවද කරන්නේ කියලා ඒ Gate එකෙන් තීරණය කරනවා.

Keycloak Support කරනවා OAuth 2.0, OpenID Connect, සහ SAML 2.0 වගේ Standard Protocols. ඒ කියන්නේ ඕනම Technology Stack එකකින් ලියපු Application එකකට මේක Use කරන්න පුළුවන් කියන එක. නියමයි නේද?

2. Keycloak ගේම් එක පටන් ගමු! 🚀

Keycloak Install කරගන්න විවිධ විදි තියෙනවා. ඒත් ඉක්මනින්ම වැඩේට බහින්න Docker තමයි Best Option එක. අපි බලමු කොහොමද Docker වලින් Keycloak Instance එකක් Run කරගන්නේ කියලා.

2.1. Docker වලින් Keycloak Setup කරමු

ඔයාගේ System එකේ Docker Install කරලා තියෙනවා නම්, මේ Simple Command එකෙන් Keycloak Server එකක් Run කරගන්න පුළුවන්:

docker run -p 8080:8080 -e KEYCLOAK_ADMIN=admin -e KEYCLOAK_ADMIN_PASSWORD=admin quay.io/keycloak/keycloak:latest start-dev

මේ Command එක ගැන පොඩ්ඩක් බලමු:

  • -p 8080:8080: Keycloak Server එකේ Port 8080, අපේ Local Machine එකේ Port 8080 ට Map කරනවා.
  • -e KEYCLOAK_ADMIN=admin: Admin Console එකට Login වෙන්න Admin Username එක 'admin' කියලා සෙට් කරනවා.
  • -e KEYCLOAK_ADMIN_PASSWORD=admin: Admin Password එක 'admin' කියලා සෙට් කරනවා. (මේක Development වලට විතරයි, Production වලට Strong Password එකක් Use කරන්න!)
  • quay.io/keycloak/keycloak:latest: Latest Keycloak Docker Image එක Use කරනවා.
  • start-dev: Development Mode එකේදී Keycloak Start කරන්න කියනවා.

Command එක Run කලාට පස්සේ පොඩි වෙලාවකින් Keycloak Server එක Start වෙයි.

2.2. Keycloak Admin Console එකට යමු

දැන් ඔයාගේ Web Browser එක Open කරලා http://localhost:8080 කියන URL එකට යන්න. එතනින් 'Administration Console' කියන Link එක Click කරන්න. එතකොට Login Page එකක් එයි. අපි කලින් දීපු Username (admin) සහ Password (admin) එක දීලා Login වෙන්න. සාදරයෙන් පිළිගන්නවා Keycloak Admin Console එකට! 🥳

2.3. Keycloak Core Concepts ටිකක් තේරුම් ගමු

Keycloak එක්ක වැඩ කරනකොට මේ Concepts ටික දැනගෙන ඉන්න එක ගොඩක් වැදගත්.

2.3.1. Realms (රජධානි)

මේක තමා Keycloak වල Fundamental එක. Realm එකක් කියන්නේ Security Domain එකක් වගේ. හැමදේම (Users, Clients, Roles, Events වගේ) තියෙන්නේ Realm එක ඇතුළේ. එක Keycloak Instance එකක Realms කිහිපයක් තියෙන්න පුළුවන්. උදාහරණයක් විදිහට, Company එකක Product එකකට එක Realm එකක්, Internal Applications වලට තව Realm එකක් වගේ Separate කරලා තියාගන්න පුළුවන්. අපි අලුතින් Realm එකක් හදමු: Admin Console එකේ වම් පැත්තේ උඩ තියෙන 'Master' Realm එකේ Dropdown එක Click කරලා 'Create realm' දෙන්න. අපේ Realm එකට නමක් දෙමු - උදා: my-app-realm.

2.3.2. Clients (ගනුදෙනුකරුවන්)

Clients කියන්නේ අපේ Applications තමා. Web Application එකක් වෙන්න පුළුවන්, Mobile App එකක් වෙන්න පුළුවන්, Microservice එකක් වෙන්න පුළුවන්. මේ Clients තමා Keycloak එකෙන් Authentication සහ Authorization Service ලබාගන්නේ. අපේ Spring Boot Application එකත් Keycloak වලට Client කෙනෙක්. 'my-app-realm' එක ඇතුළේ 'Clients' කියන Section එකට ගිහින් 'Create client' දෙන්න. 'Client ID' එකට spring-boot-app කියලා දෙන්න. 'Client authentication' enable කරලා 'Standard flow' enable කරන්න. 'Valid Redirect URIs' වලට http://localhost:8081/login/oauth2/code/keycloak සහ http://localhost:8081/* දෙන්න. (Spring Boot Application එක Run වෙන්නේ 8081 Port එකේ කියලා හිතමු).

2.3.3. Users (පරිශීලකයින්)

අපේ System එකට Login වෙන අය තමා Users. 'my-app-realm' එක ඇතුළේ 'Users' කියන Section එකට ගිහින් 'Add user' දෙන්න. Username, Email වගේ Details දීලා User කෙනෙක් හදන්න. ඊට පස්සේ 'Credentials' Tab එකට ගිහින් ඒ User ට Password එකක් සෙට් කරන්න.

2.3.4. Roles (භූමිකා)

මේක තමා User කෙනෙක්ට System එකේ මොනවද කරන්න පුළුවන් කියලා කියන්නේ. උදා: admin, user, manager. 'my-app-realm' එකේ 'Roles' Section එකට ගිහින් 'Add role' දීලා app_user වගේ Role එකක් හදන්න. ඊට පස්සේ කලින් හදපු User ගේ 'Role Mappings' Tab එකට ගිහින් ඒ User ට app_user Role එක Assign කරන්න.

3. Spring Boot එක්ක යාලු කරමු! 🤝

දැන් අපි බලමු කොහොමද අපේ Spring Boot Application එක Keycloak එක්ක Connect කරගන්නේ කියලා. අපි OAuth 2.0 Login Flow එක Use කරමු.

3.1. Dependencies Add කරමු (pom.xml)

ඔයාගේ pom.xml එකට මේ Dependencies ටික Add කරගන්න:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-oauth2-client</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
</dependencies>

spring-boot-starter-oauth2-client එක තමයි OAuth 2.0 Clients විදිහට වැඩ කරන්න අවශ්‍ය සියලුම Features අරන් එන්නේ. spring-boot-starter-web සහ spring-boot-starter-security කියන්නේ Basic Web සහ Security Dependencies.

3.2. application.properties/application.yml Configuration

මේක තමයි වැඩේට අත්‍යවශ්‍යම කොටස. ඔයාගේ src/main/resources/application.yml (හෝ application.properties) එකට මේ Configuration ටික Add කරන්න:

server:
  port: 8081 # අපේ Spring Boot App එක මේ Port එකේ Run වෙන්න සෙට් කරමු.

spring:
  security:
    oauth2:
      client:
        registration:
          keycloak:
            client-id: spring-boot-app # Keycloak Client ID එක. (කලින් හදපු එක)
            client-secret: <your-client-secret-from-keycloak> # Keycloak Client Secret එක. 'Clients' -> 'spring-boot-app' -> 'Credentials' Tab එකේ තියෙනවා.
            scope: openid,profile,email # අපිට Keycloak වලින් ගන්න ඕන User Information වර්ග.
            redirect-uri: "{baseUrl}/login/oauth2/code/{registrationId}" # Auth flow එකෙන් පස්සේ ආපහු Redirect වෙන URL එක.
            client-authentication-method: client_secret_post # Client Secret එක යවන විදිහ.
            authorization-grant-type: authorization_code # OAuth 2.0 Flow එක.
        provider:
          keycloak:
            authorization-uri: http://localhost:8080/realms/my-app-realm/protocol/openid-connect/auth # Keycloak Auth Endpoint එක.
            token-uri: http://localhost:8080/realms/my-app-realm/protocol/openid-connect/token # Keycloak Token Endpoint එක.
            user-info-uri: http://localhost:8080/realms/my-app-realm/protocol/openid-connect/userinfo # User Information Endpoint එක.
            jwk-set-uri: http://localhost:8080/realms/my-app-realm/protocol/openid-connect/certs # JWT Signature Validation Endpoint එක.
            user-name-attribute: preferred_username # User නම ගන්න Keycloak response එකේ තියෙන Attribute එක.

<your-client-secret-from-keycloak> තැනට ඔයාගේ Keycloak Client එකේ (spring-boot-app) Credentials Tab එකේ තියෙන Secret එක දාන්න අමතක කරන්න එපා. ඒ වගේම my-app-realm කියන තැනට ඔයා හදපු Realm එකේ නම දෙන්න.

3.3. Spring Security Configuration

දැන් අපි Spring Security Configure කරමු. src/main/java එකේ අලුත් Package එකක් හදලා ඒක ඇතුළේ SecurityConfig.java කියලා Class එකක් හදන්න:

package com.example.keycloakdemo.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeRequests(authorizeRequests ->
                authorizeRequests
                    .antMatchers("/", "/public").permitAll() // මේ Paths වලට හැමෝටම Access දෙන්න.
                    .anyRequest().authenticated() // අනිත් හැම Request එකකටම Authenticate වෙන්න ඕන.
            )
            .oauth2Login(Customizer.withDefaults()); // OAuth2 Login Enable කරනවා.
        return http.build();
    }
}

මේ Code එකෙන් කියන්නේ:

  • / සහ /public කියන URL Paths වලට ඕනම කෙනෙක්ට (Authenticated නැති අය උනත්) Access කරන්න පුළුවන්.
  • අනිත් හැම URL Path එකකටම Access කරන්න නම් User කෙනෙක් Authenticate වෙලා ඉන්න ඕන.
  • oauth2Login(Customizer.withDefaults()) කියන Method එක Spring Security වලට කියනවා OAuth 2.0 Login Flow එක Use කරන්න කියලා. ඒකෙන් Auto Configure වෙනවා Login Redirect, Token Exchange වගේ දේවල්.

3.4. Simple Controller එකක් හදමු

දැන් අපි Simple Controller එකක් හදලා Secured සහ Public Endpoints දෙකක් බලමු. src/main/java එකේ අලුත් Package එකක් හදලා ඒක ඇතුළේ MyController.java කියලා Class එකක් හදන්න:

package com.example.keycloakdemo.controller;

import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.security.oauth2.core.user.OAuth2User;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {

    @GetMapping("/public")
    public String publicPage() {
        return "<h1>Welcome to the Public Page!</h1><p>Anyone can access this page without logging in.</p>";
    }

    @GetMapping("/secured")
    public String securedPage(@AuthenticationPrincipal OAuth2User oauth2User) {
        if (oauth2User != null) {
            String name = oauth2User.getAttribute("name");
            String email = oauth2User.getAttribute("email");
            return "<h1>Hello, " + name + "!</h1>" +
                   "<p>You are on a secured page. Your email is: " + email + "</p>" +
                   "<p><a href=\"/logout\">Logout</a></p>";
        } else {
            return "<h1>You are not logged in.</h1><p>Please log in to access this page.</p>";
        }
    }

    @GetMapping("/")
    public String homePage() {
        return "<h1>Home Page!</h1><p><a href=\"/public\">Public Page</a> | <a href=\"/secured\">Secured Page</a></p>";
    }
}

මේ Controller එකේ /secured Endpoint එකට @AuthenticationPrincipal OAuth2User oauth2User කියන Parameter එක දීලා තියෙනවා. මේකෙන් පුළුවන් Authenticated වෙච්ච User ගේ Details (නම, Email වගේ) Keycloak වලින් අරගෙන අපේ Application එක ඇතුළේ Use කරන්න. මේ Attributes ටික Keycloak එකෙන් එවන OpenID Connect token එකේ Payload එකේ තියෙනවා.

4. වැඩ කරන හැටි බලමු! 🎬

දැන් ඔයාගේ Spring Boot Application එක Run කරන්න. (IntelliJ IDEA එකෙන් නම් Run කරන්න, නැත්නම් Terminal එකේ mvn spring-boot:run කියලා Type කරන්න.) Application එක Start උනාට පස්සේ:

  1. Public Page එකට යන්න: Browser එකේ http://localhost:8081/public කියලා යන්න. මේක කිසිම Login එකක් නැතිව පෙනෙන්න ඕන.
  2. Secured Page එකට යන්න: දැන් http://localhost:8081/secured කියලා යන්න. මොකද වෙන්නේ? කෙලින්ම Keycloak Login Page එකට Redirect වෙන්න ඕන!
  3. Login වෙන්න: Keycloak Login Page එකේදී ඔයා කලින් Keycloak Admin Console එකේදී හදපු User ගේ Username සහ Password එක දීලා Login වෙන්න.
  4. Secured Page එකට එන්න: සාර්ථකව Login උනාට පස්සේ, ඔයාගේ Browser එක ආපහු Spring Boot Application එකේ /secured Page එකට Redirect වෙයි. දැන් ඒ Page එකේ ඔයාගේ User Name එක සහ Email එක පෙනෙන්න ඕන! නියමයි නේද?

Troubleshooting Tips:

  • Redirect URI Error: Keycloak Admin Console එකේ Client එකේ Valid Redirect URIs හරියට දීලා තියෙනවද කියලා Check කරන්න. එක Space එකක් හරි වැරදුනොත් වැඩ කරන්නේ නෑ.
  • Client Secret: application.yml එකේ Client Secret එක හරියට දාලා තියෙනවද කියලා බලන්න.
  • Keycloak Server Status: Keycloak Docker Container එක Run වෙනවද කියලා Check කරන්න. docker ps Command එකෙන් බලන්න පු liệt kê.
  • Logs: Spring Boot Application එකේ Console Logs Check කරන්න. මොනවා හරි Error එකක් තියෙනවා නම් එතන පෙන්නයි.

අවසන් වචන 🏁

මේක Keycloak සහ Spring Boot Security වල මූලිකම පියවර විතරයි. මේක Spring Boot Applications වල Security එක තවදුරටත් ශක්තිමත් කරන්න තියෙන නියම Tool එකක්. Keycloak වල මේ වගේ තව හුඟක් Features තියෙනවා – Roles, Groups, Multi-Factor Authentication (MFA), Social Logins (Google, Facebook වගේ), Custom User Storage SPIs වගේ දේවල්. මේ හැමදේම ගැන ඉදිරියේදී අපි තව දුරටත් කතා කරමු.

ඔයාලත් මේක Try කරලා බලන්න. මොනවා හරි ප්‍රශ්න තියෙනවා නම්, මේ Article එකේ මොනවා හරි පැහැදිලි නැති තැන් තියෙනවා නම්, නැත්නම් මේ වගේ තව මොනවා ගැනද දැනගන්න ඕන කියලා හිතෙනවා නම් Comment Section එකේ අහන්න අමතක කරන්න එපා! 💬

එහෙනම්, තවත් සුපිරි Article එකකින් හමුවෙමු! Happy Coding! 👋

Previous

Spring Boot එකේ Password ආරක්ෂා කරමු: BCryptPasswordEncoder SC Guide

 Next

Keycloak Client Configuration සිංහලෙන්: Advanced Authentication Flows සහ SSO (SC Guide)

You might also like...