By Thisara Priyamal — 07 Jul 2025

Jenkins CI/CD Pipeline Sri Lanka - අතින් කරන වැඩ අඩු කරමු SC Guide

ආයුබෝවන් හැමෝටම! කොහොමද යාලුවනේ?

මේ දවස්වල Software Development ලෝකේ හරිම වේගයෙන් දියුණු වෙනවා නේද? අලුතින් Tools එනවා, Technologies එනවා, කට්ටියගේ වැඩ ගොඩකුත් වැඩිවෙනවා. අපේ Application එකක් හදලා ඉවර වුණාම, ඒවා Build කරලා, Test කරලා, ඊටපස්සේ Production එකට Deployment කරන එක ටිකක් අමාරු වැඩක් නේද? හැමදාම Manual විදිහට මේවා කරනකොට වැරදෙන තැනුත් වැඩි වෙනවා, වෙලාවත් යනවා. ඒ වගේම, අපේ Code එකේ පොඩි වෙනසක් කරාම ආයෙත් මුල ඉඳන්ම මේ ඔක්කොම ටික කරන්න සිද්ධ වෙන එක මහ මගුලක් නේද?

කට්ටියම මේ ප්‍රශ්නෙට හොඳ, ස්ථිරසාර විසඳුමක් හොයනවා ඇති. අන්න ඒකට තමයි අද අපි කතා කරන්නේ CI/CD ගැන, විශේෂයෙන්ම අපේ හොඳම යාළුවා වගේ වැඩ කරන Jenkins ගැන. මේ ලිපියෙන් අපි බලමු කොහොමද Jenkins පාවිච්චි කරලා අපේ Application එකේ Build එකයි, Deployment එකයි Automate කරගන්නේ කියලා. එහෙනම්, අපි වැඩේට බහිමුද?

CI/CD කියන්නේ මොකක්ද මේ? අපි කතා කරමු!

CI/CD කියන්නේ හරිම වැදගත් Concept එකක්. හැබැයි අහන අයට ටිකක් අවුල් වෙන්න පුළුවන්. ඒක නිසා අපි සරලවම කතා කරමු.

1. CI (Continuous Integration) - එකතු වෙලා වැඩ කරමු!

සරලවම කිව්වොත්, CI කියන්නේ Development Team එකේ හැමෝම තමන්ගේ Code එක නිතරම (දවසට කීප වතාවක් වුණත්) Main Code Repository එකට (Git වගේ) Merge කරන එක. එහෙම Merge කරාම, ස්වයංක්‍රීයව (Automated) Build එකක් යනවා, Tests run වෙනවා. මේකෙන් වෙන්නේ පොඩි පොඩි Bugs එනකොටම අල්ලගන්න පුළුවන් වෙන එක, මොකද Code එක එකතු කරපු ගමන්ම Test වෙන නිසා. කට්ටියම එකට එකතු වෙලා වැඩ කරනකොට එන ගැටලු අඩු කරගන්න CI හරිම වැදගත්.

2. CD (Continuous Delivery/Deployment) - Deliver කරමු, Deploy කරමු!

CI කරාට පස්සේ එන්නේ CD. මේක කොටස් දෙකකට බෙදන්න පුළුවන්:

Continuous Delivery: මේකෙන් කියවෙන්නේ අපේ Code එක Build කරලා, Test කරලා, Production එකට Deploy කරන්න පුළුවන් තත්වෙට හැමවිටම තියාගන්න එක. හැබැයි, Actual Production Deployment එකට Manual Approval එකක් ඕනේ වෙන්න පුළුවන්. ඒ කියන්නේ, Code එක Ready වුණාට, කවුරුහරි Manualy "Deploy" Button එක ඔබන්න ඕනේ කියන එක.
Continuous Deployment: මේක Continuous Delivery එකේ තවත් ඉදිරි පියවරක්. මෙතනදී, Code එක Production එකට යනකම් කිසිම Manual Intervention එකක් නැතුව, ස්වයංක්‍රීයවම යනවා. ඒ කියන්නේ, Test ටික Pass වුණා නම්, කෙලින්ම Production එකට Deploy වෙනවා. මේක තමයි Full Automation කියන්නේ! අම්මෝ ඒක නම් නියමයි නේ?

මේ CI/CD Process එක හරියට දාගත්තොත්, Bugs අඩු වෙනවා, Deployments වේගවත් වෙනවා, Quality එක වැඩි වෙනවා, අන්තිමට Customer සතුටු වෙනවා.

ඇයි අපිට Jenkins ඕනේ? මොකක්ද මේකේ තියෙන විශේෂත්වය?

CI/CD කරන්න Tool ගොඩක් තිබ්බත් (GitLab CI, GitHub Actions, CircleCI, Travis CI වගේ), Jenkins කියන්නේ අවුරුදු ගාණක ඉඳන් මේ ලෝකේ ඉන්න, Open-source, පුළුල්ව පාවිච්චි වෙන, Plugins ගොඩක් තියෙන සුපිරි Tool එකක්. ඒක තමයි ගොඩක් Company වලට මේක ප්‍රධාන Tool එකක් වෙලා තියෙන්නේ.

Jenkins පාවිච්චි කිරීමේ වාසි:

Open-Source සහ Free: මේක Free Tool එකක් නිසා, පොඩි Project වල ඉඳන් ලොකු Enterprise Project දක්වා ඕනෑම කෙනෙකුට පාවිච්චි කරන්න පුළුවන්.
Plugin Ecosystem: Jenkins වලට Plugins දහස් ගණනක් තියෙනවා. Git, Maven, Docker, AWS, Kubernetes වගේ ඕනෑම Tool එකක් එක්ක integrate වෙන්න පුළුවන්. මේකෙන් අපිට ඕනෑම දෙයක් Automate කරන්න පුළුවන්.
Highly Customizable: ඔයාලගේ Project එකේ අවශ්‍යතාවලට අනුව Pipeline එක හදාගන්න පුළුවන්. පුළුල් Flexibility එකක් තියෙනවා.
Distributed Builds: Jenkins Agents/Nodes පාවිච්චි කරලා Build Process එක වෙන වෙන Servers වලට බෙදලා කරන්න පුළුවන්. මේකෙන් Build Time එක අඩු කරගන්න පුළුවන්.
Community Support: විශාල User Community එකක් ඉන්න නිසා, මොනවා හරි ප්‍රශ්නයක් ආවොත් උදව් හොයාගන්න ලේසියි.

ඒ වගේම, Jenkins Pipeline කියන්නේ Code විදිහට අපේ Automation Flow එක ලියන්න පුළුවන් නියම පහසුකමක්. මේක Groovy DSL (Domain Specific Language) එකක් පාවිච්චි කරලා ලියන්නේ. අපි බලමු මේක කොහොමද කරන්නේ කියලා.

Jenkins සෙට් කරගමුකො! (Installation and Basic Setup)

Jenkins Install කරන එක එච්චර අමාරු නෑ. Linux, Windows, Docker වගේ ඕනම Operating System එකක හෝ Platform එකක Install කරන්න පුළුවන්. Official website එකේ හොඳ Guides තියෙනවා. උදාහරණයක් විදිහට, Docker පාවිච්චි කරනවා නම්, මේ විදිහට එක Command එකකින් Install කරන්න පුළුවන්:

docker run -p 8080:8080 -p 50000:50000 --name jenkins -v jenkins_home:/var/jenkins_home jenkins/jenkins:lts

මේකෙන් වෙන්නේ Jenkins Docker Container එකක් Start වෙන එක. ඊට පස්සේ Browser එකේ http://localhost:8080 ගිහින් Initial Setup එක කරගන්න පුළුවන්. අපි හිතමු ඔයාලා Jenkins Server එකක් සෙට් කරගත්තා කියලා.

අත්‍යවශ්‍ය Plugins ටිකක්!

Jenkins Install කරාට පස්සේ, අපිට Pipeline එකක් හදන්න අත්‍යවශ්‍ය Plugins ටිකක් Install කරන්න ඕනේ. සාමාන්‍යයෙන් Initial Setup එකේදී Recommended Plugins Install කරන්න ඔප්ෂන් එකක් දෙනවා. එතකොට ගොඩක් ඒවා Install වෙනවා. නැතිනම්, Jenkins Dashboard එකේ Manage Jenkins -> Manage Plugins ගිහින් මේවා Search කරලා Install කරගන්න:

Git: Code Repository එකෙන් Code එක ගන්න.
Pipeline: Pipeline එකක් Run කරන්න.
Maven Integration / Gradle: Java Project Build කරන්න. (ඔයාලා පාවිච්චි කරන Build Tool එක අනුව)
Docker Plugin / Docker Pipeline: Docker Images එක්ක වැඩ කරන්න.
SSH Pipeline Steps / SSH Publisher: Remote Server වලට Deploy කරන්න.

මේ ටික Install කරගත්තා නම්, අපි Pipeline එකක් හදන්න ලෑස්තියි!

අපේ පළමු Pipeline එක හදමු! (Jenkinsfile)

Jenkins Pipeline එකක් කියන්නේ අපේ CI/CD Steps ටික Code විදිහට ලියන එක. මේක අපි Jenkinsfile කියලා File එකක Project එකේ Root එකේ තියනවා. මේක Git වල Commit කරලා තියන්න පුළුවන් නිසා, අපේ Pipeline එකත් Version Control වෙනවා.

සරල `Jenkinsfile` එකක් හදමු:

අපි හිතමු අපිට Java Maven Application එකක් තියෙනවා කියලා. මේක Clone කරලා, Build කරලා, Test කරලා, ඊට පස්සේ Docker Image එකක් හදලා Docker Registry එකකට Push කරන Pipeline එකක් හදමු.

// Jenkinsfile
pipeline {
    // Agent: Pipeline එක Run වෙන්නේ කොහෙද කියලා කියනවා.
    // 'any' කිව්වොත්, ඕනෑම Available Agent එකක Run වෙනවා.
    agent any

    // Stages: Pipeline එකේ ප්‍රධාන කොටස්.
    // එක එක Stage එකේදී එක එක වැඩේ වෙනවා.
    stages {
        stage('Checkout Code') {
            steps {
                // Git Repository එකෙන් Code එක Checkout කරනවා.
                // 'https://github.com/your-org/your-app.git' එක ඔයාලගේ Repository එකට වෙනස් කරන්න.
                git 'https://github.com/your-org/your-app.git'
                // Credential ID එකක් පාවිච්චි කරනවා නම්: git credentialsId: 'your-git-credentials', url: 'https://github.com/your-org/your-app.git'
            }
        }
        stage('Build Application') {
            steps {
                script {
                    // මෙතනදී අපි Build Commands දානවා.
                    // Maven, Gradle, npm, yarn, Go, Python වගේ ඕනෑම Build Tool එකක් පාවිච්චි කරන්න පුළුවන්.
                    // isUnix() කියන්නේ Linux/macOS ද කියලා බලනවා. Windows නම් bat පාවිච්චි කරන්න ඕනේ.
                    if (isUnix()) {
                        sh 'mvn clean install -DskipTests' // Java Maven app එකක් නම්.
                        // NodeJS app එකක් නම්:
                        // sh 'npm install'
                        // sh 'npm run build'
                    } else {
                        bat 'mvn clean install -DskipTests'
                    }
                }
            }
        }
        stage('Run Unit Tests') {
            steps {
                script {
                    // Unit Tests Run කරනවා.
                    if (isUnix()) {
                        sh 'mvn test' // Java Maven app එකක් නම්.
                        // NodeJS app එකක් නම්:
                        // sh 'npm test'
                    } else {
                        bat 'mvn test'
                    }
                }
            }
        }
        stage('Build Docker Image') {
            steps {
                script {
                    // Docker Image එකක් Build කරනවා.
                    // Jenkins Agent එකේ Docker Install කරලා තියෙන්න ඕනේ.
                    // 'docker-hub-credentials' කියන්නේ Jenkins වල Add කරපු Credential ID එක.
                    withDockerRegistry([ credentialsId: 'docker-hub-credentials', url: 'https://index.docker.io/v1/' ]) {
                        sh 'docker build -t your-docker-repo/your-app:${BUILD_NUMBER} .'
                        // Build_NUMBER කියන්නේ Jenkins Build එකේ අංකය. මේකෙන් Unique Tag එකක් හදන්න පුළුවන්.
                        // Image එක Docker Registry එකට Push කරනවා.
                        sh 'docker push your-docker-repo/your-app:${BUILD_NUMBER}'
                    }
                }
            }
        }
    }

    // Post-actions: Pipeline එක ඉවර වුණාට පස්සේ කරන වැඩ.
    post {
        success {
            echo 'Pipeline successfully completed! සුභ ආරංචියි!'
        }
        failure {
            echo 'Pipeline failed. කණගාටුයි, Logs බලන්න!'
            // Slack, Email වගේ Alerts යවන්නත් පුළුවන් මෙතනින්.
        }
        always {
            echo 'This will always run.'
        }
    }
}

Jenkins එකේ Project එක හදමු:

දැන් Jenkinsfile එක හදාගත්තා නම්, අපි මේක Jenkins එකට හඳුන්වා දෙමු.

Jenkins Dashboard එකට ගිහින් New Item කියන එක Click කරන්න.
Project එකට නමක් දෙන්න (උදා: MyJavaApp-CI-Pipeline) සහ Pipeline කියන Project Type එක තෝරලා OK කරන්න.
Configure Page එකේ General යටතේ GitHub project කියන එක Tick කරලා, ඔයාලගේ GitHub Repository එකේ URL එක දෙන්න. (ඔයාලගේ Code එක තියෙන තැන)
Build Triggers යටතේ GitHub hook trigger for GITScm polling කියන එක Tick කරන්න. මේකෙන් වෙන්නේ, Git Repository එකට අලුත් Code එකක් Push කරපු ගමන්, Jenkins එකට Build එකක් Start කරන්න Notification එකක් එන එක.
Pipeline Section එකට යන්න.
Definition එක Pipeline script from SCM විදිහට වෙනස් කරන්න.
SCM එකට Git තෝරන්න.
Repository URL එකට ඔයාලගේ Git Repository එකේ URL එක දෙන්න.
Credentials: Private Repository එකක් නම්, Add button එක Click කරලා Username/Password හෝ SSH Key එකක් එකතු කරගන්න.
Branches to build: */main (මේකෙන් කියවෙන්නේ main Branch එකේ වෙනස්කමක් වුණොත් Pipeline එක Run කරන්න කියන එක.)
Script Path: Jenkinsfile (අපි හදපු Jenkinsfile එක තියෙන Path එක. Project Root එකේ තියෙනවා නම් මේකම ඇති.)
Save කරන්න.

දැන් ඔයාලා Git Repository එකට අලුත් Code එකක් Push කරාම, Jenkins එක ස්වයංක්‍රීයව Build එකක් Start කරයි. ඒකෙන් අපේ Pipeline එක Run වෙන හැටි Dashboard එකේ බලාගන්න පුළුවන්.

Deployment automate කරමු! (CD Section)

අපේ App එක Build කරලා, Test කරලා ඉවරනේ. දැන් මේක Server එකට දාමු. අපි Docker Image එකක් හදාගත්ත නිසා, ඒක Deploy කරන එක හරිම ලේසියි.

1. Remote Server එකට SSH හරහා Deploy කරමු!

අපි හිතමු අපිට Remote Server එකක් තියෙනවා කියලා, අපේ Docker Image එක අරගෙන Run කරන්න. මේකට අපි sshPublisher Plugin එක පාවිච්චි කරමු. මුලින්ම, Jenkins වලට Server එකේ SSH Credentials Add කරගන්න ඕනේ:

Manage Jenkins -> Manage Credentials -> Global credentials (unrestricted) -> Add Credentials
Kind: Username with password හෝ SSH Username with private key තෝරන්න.
Username, Password / Private Key ටික දීලා, ID එකක් දෙන්න (උදා: remote-server-credentials).
Manage Jenkins -> Configure System යටතේ, SSH remote hosts Section එකට ගිහින්, Add button එක Click කරලා Server එකේ IP Address එක, Name එක (උදා: MyStagingServer), Credentials ID එක දීලා Test Connection කරන්න.

දැන් අපේ Jenkinsfile එකට Deployment Stage එකක් එකතු කරමු:

// Jenkinsfile (Add this new stage after 'Build Docker Image' stage)
pipeline {
    agent any
    stages {
        // ... (previous stages like Checkout, Build, Test, Build Docker Image)

        stage('Deploy to Staging Server') {
            steps {
                script {
                    // Docker Image එක Remote Server එකට Pull කරලා Run කරනවා.
                    // 'your-docker-repo/your-app' එක ඔයාලගේ Image නමට වෙනස් කරන්න.
                    def dockerImage = "your-docker-repo/your-app:${BUILD_NUMBER}"

                    // sshPublisher පාවිච්චි කරන්නේ නැතුව, SSH Agent එකකින් කෙලින්ම Shell Commands දෙන්නත් පුළුවන්.
                    sshagent(credentials: ['remote-server-credentials']) {
                        sh "ssh -o StrictHostKeyChecking=no user@your_remote_server_ip 'docker pull ${dockerImage}'"
                        sh "ssh -o StrictHostKeyChecking=no user@your_remote_server_ip 'docker stop your-app-container || true'"
                        sh "ssh -o StrictHostKeyChecking=no user@your_remote_server_ip 'docker rm your-app-container || true'"
                        sh "ssh -o StrictHostKeyChecking=no user@your_remote_server_ip 'docker run -d --name your-app-container -p 80:80 ${dockerImage}'"
                    }

                    // නැතහොත්, sshPublisher plugin එකෙන් file transfer කරලා command run කරන්නත් පුළුවන්
                    // sshPublisher(publishers: [
                    //     sshPublisherConfig(
                    //         configName: 'MyStagingServer', // Configure this in Jenkins System Settings
                    //         transfers: [
                    //             sshTransfer(
                    //                 sourceFiles: 'path/to/your/built/artifact.jar', // if not using docker image
                    //                 removePrefix: 'path/to/your/built/',
                    //                 remoteDirectory: '/var/www/your-app',
                    //                 execCommand: "docker pull ${dockerImage} && docker stop your-app-container || true && docker rm your-app-container || true && docker run -d --name your-app-container -p 80:80 ${dockerImage}"
                    //             )
                    //         ]
                    //     )
                    // ])
                }
            }
        }
    }
    post {
        // ... (existing post-actions)
    }
}

මේ Jenkinsfile එකෙන් වෙන්නේ Docker Image එක Build කරලා, ඒක Remote Server එකට Pull කරලා, කලින් තිබ්බ Container එක නවත්තලා අලුත් එක Start කරන එක. මේක තමයි Deployment Automation කියන්නේ!

2. Kubernetes වලට Deploy කරමු!

දැන් දවසට ගොඩක් අය Kubernetes පාවිච්චි කරනවා. Jenkins එක්ක Kubernetes වලට Deploy කරන එකත් හරිම ලේසියි. අපිට Kubernetes Plugin, Helm Plugin වගේ ඒවා පාවිච්චි කරන්න පුළුවන්. නැත්නම්, Jenkins Agent එකේ kubectl Install කරලා තියෙනවා නම්, කෙලින්ම Shell Command විදිහට Deploy කරන්න පුළුවන්:

// Add this stage to your Jenkinsfile
stage('Deploy to Kubernetes') {
    steps {
        script {
            // Make sure kubectl is configured on the Jenkins agent
            // Replace 'your-kubeconfig-credential' with a suitable Jenkins credential for Kubeconfig
            withKubeConfig(credentialsId: 'your-kubeconfig-credential') {
                sh "kubectl apply -f k8s/deployment.yaml" // Apply Kubernetes Deployment manifest
                sh "kubectl set image deployment/your-app your-app=your-docker-repo/your-app:${BUILD_NUMBER}" // Update image
                // For Helm deployments:
                // sh "helm upgrade --install your-app ./helm-charts/your-app --set image.tag=${BUILD_NUMBER}"
            }
        }
    }
}

මෙතනදී අපි Kubernetes Deployment Files apply කරනවා, නැත්නම් Helm Charts deploy කරනවා.

වැදගත් Tips සහ Best Practices!

Jenkins Pipeline එකක් හදනකොට මේ දේවල් මතක තියාගන්න එක හරිම වැදගත්.

Credentials Security: Sensitive Information (API Keys, Passwords) කිසි විටක Jenkinsfile එකේ කෙලින්ම ලියන්න එපා. Jenkins Credentials Store එක පාවිච්චි කරන්න.
Build Agents: Jenkins Master Server එකේම Build කරන්න එපා. Dedicated Build Agents/Nodes පාවිච්චි කරන්න. මේකෙන් Master එකේ Load එක අඩු වෙනවා, ඒ වගේම Build Speed එක වැඩි වෙනවා.
Modular Pipelines: ලොකු Pipelines එකම File එකක ලියන්නේ නැතුව, Shared Libraries පාවිච්චි කරලා කොටස් වලට කඩන්න. මේකෙන් Code Reuse කරන්න පුළුවන්, Maintenance ලේසියි.
Error Handling: try-catch-finally වගේ දේවල් පාවිච්චි කරලා Errors හරියට Handle කරන්න. Pipeline එක Fail වුණොත්, Notification යවන්න.
Monitoring and Logging: Pipeline Runs නිතරම Monitor කරන්න, Logs Check කරන්න. මේකෙන් ගැටලු ඉක්මනින් හොයාගන්න පුළුවන්.
Atomic Deployments: Deployment Fail වුණොත් Rollback කරන්න පුළුවන් විදිහට Plan කරන්න. Blue/Green Deployment, Canary Deployment වගේ Strategies ගැන ඉගෙන ගන්න.

අවසාන වශයෙන්…

අපි අද Jenkins පාවිච්චි කරලා CI/CD Pipeline එකක් හදාගන්න විදිහ ගැන ඉගෙන ගත්තා. මේකෙන් ඔයාලගේ Development Process එක කොච්චර වේගවත් වෙනවද, වැරදි අඩු වෙනවද, ඒ වගේම Quality එක කොච්චර වැඩි වෙනවද කියලා ඔයාලටම තේරෙයි. අතින් කරන වැඩ අඩු වෙනකොට, Developers ලට වැඩිපුර Focus කරන්න පුළුවන් Product එකේ Quality එකයි, New Features වලයි. ඒකෙන් Company එකේ Productivity එකත් වැඩි වෙනවා.

ඉතින්, තවත් කල් නොදා අදම ඔයාලගේ Project එකකට Jenkins Pipeline එකක් හදලා බලන්න! මුලදී ටිකක් අමාරු වගේ පෙනුනත්, පුරුදු වෙනකොට මේක හරිම ලේසියි. මොනවා හරි ප්‍රශ්න තියෙනවා නම්, පහලින් Comment කරන්න. අපි උත්සාහ කරමු උදව් කරන්න. මේ වගේ තවත් Article එකකින් හමුවෙමු! සුභ දවසක්!

Jenkins CI/CD Pipeline Sri Lanka - අතින් කරන වැඩ අඩු කරමු SC Guide

ආයුබෝවන් හැමෝටම! කොහොමද යාලුවනේ?

CI/CD කියන්නේ මොකක්ද මේ? අපි කතා කරමු!

1. CI (Continuous Integration) - එකතු වෙලා වැඩ කරමු!

2. CD (Continuous Delivery/Deployment) - Deliver කරමු, Deploy කරමු!

ඇයි අපිට Jenkins ඕනේ? මොකක්ද මේකේ තියෙන විශේෂත්වය?

Jenkins පාවිච්චි කිරීමේ වාසි:

Jenkins සෙට් කරගමුකො! (Installation and Basic Setup)

අත්‍යවශ්‍ය Plugins ටිකක්!

අපේ පළමු Pipeline එක හදමු! (Jenkinsfile)

සරල `Jenkinsfile` එකක් හදමු:

Jenkins එකේ Project එක හදමු:

Deployment automate කරමු! (CD Section)

1. Remote Server එකට SSH හරහා Deploy කරමු!

2. Kubernetes වලට Deploy කරමු!

වැදගත් Tips සහ Best Practices!

අවසාන වශයෙන්…

Java වල Database Connect කරමු - JDBC MySQL Oracle SC Guide

JDBC Statement & ResultSet: Database වැඩ Sinhala වලින්!

ආයුබෝවන් හැමෝටම! කොහොමද යාලුවනේ?

CI/CD කියන්නේ මොකක්ද මේ? අපි කතා කරමු!

1. CI (Continuous Integration) - එකතු වෙලා වැඩ කරමු!

2. CD (Continuous Delivery/Deployment) - Deliver කරමු, Deploy කරමු!

ඇයි අපිට Jenkins ඕනේ? මොකක්ද මේකේ තියෙන විශේෂත්වය?

Jenkins පාවිච්චි කිරීමේ වාසි:

Jenkins සෙට් කරගමුකො! (Installation and Basic Setup)

අත්‍යවශ්‍ය Plugins ටිකක්!

අපේ පළමු Pipeline එක හදමු! (Jenkinsfile)

සරල Jenkinsfile එකක් හදමු:

Jenkins එකේ Project එක හදමු:

Deployment automate කරමු! (CD Section)

1. Remote Server එකට SSH හරහා Deploy කරමු!

2. Kubernetes වලට Deploy කරමු!

වැදගත් Tips සහ Best Practices!

අවසාන වශයෙන්…

Java වල Database Connect කරමු - JDBC MySQL Oracle SC Guide

JDBC Statement & ResultSet: Database වැඩ Sinhala වලින්!

සරල `Jenkinsfile` එකක් හදමු: