Forem: Devops Kiponos

Skip tests while build running?

Devops Kiponos — Thu, 12 Feb 2026 18:23:57 +0000

That's easy with the right SDK!

There is a free service allowing you exactly that!

Your build is running.
You enter your account online and change a value.
The SDK in your tests instantly detect the change at runtime.

That's it.

The SDK has:

get(fieldName)
- Any time you get, it's always the latest value you have online in your dashboard!
onValueChanged( changeInfo ) { ...your code to handle change... changeInfo.getFieldName(), changeInfo.getValue(), etc... }
- When you change a value online, your code can react instantly, in true real-time to the change! the SDK is notified instantly using internal, highly secured websocket connection.

Latency is ZERO! and here is why:

Kiponos server dispatch delta-changes only directly to your SDK.
The SDK always have the latest values in-memory, locally in your code.
Accessing your data via the SDK is exactly the same as accessing any local variable in your code!
Only the delta-change dispatch will cost between 1ms to 3ms. After that, the SDK has the latest value locally so your code runs on latest values - from the update point on - with true zero latency!

How to install and use the SDK

(free forever account)

Get the SDK Keys for your envs here: kiponos.io

Copy these tokens generated for you in your account (in "Connect Your App") and set them in your env:

export KIPONOS_ID="your-kiponos-id"
export KIPONOS_ACCESS="your-kiponos-access"

For Python SDK:

To install the Kiponos Python SDK, run the command:

pip install kiponos-pysdk

(Python 3.12 or higher).

Usage

from kiponos_pysdk import KiponosClient

client = KiponosClient(kiponos="['my-app']['1.0.0']['dev']['base']")
client.connect()

# Get a config value
print(client.get("timeout", "not found"))  # e.g., "100"

For Java SDK (fully compatible with SpringBoot):

Simply include the SDK in your Gradle build file:

dependencies {
    implementation 'io.kiponos:sdk-boot-3:4.4.0.250319'
}

Or Maven:

<dependency>
    <groupId>io.kiponos</groupId>
    <artifactId>sdk-boot-3</artifactId>
    <version>4.4.0.250319</version>
</dependency>

Usage:

import io.kiponos.Kiponos;

public class Example {
    public static void main(String[] args) {
        Kiponos cfg = Kiponos.createForCurrentTeam();

        // Example of using the SDK.
        // get always return the latest value you have online.
        String paymentsHealthUrl = cfg.path("Health-Checks", "PaymentService").get("health-url");

        System.out.println("Payments Health URL: " + paymentsHealthUrl);

        // Optional - if you also want to run some 
        // code anytime a specific field is changed: 
        cfg.afterValueUpdated(valUpdated -> {
            // Handle the updated value
            if ("health-api".equals(valUpdated.getKey())) {
                // Code instantly runs when the value updated.
            }
        });
    }
}

For CICD Tests

Exactly the same in tests context as in main:

Just define your config key that control your tests

E.g: Define enable-tests directly in the root config folder.

In your test, use JUnit Assumptions to powerfully integrate with Kiponos SDK:

package io.kiponos;

import io.kiponos.sdk.Kiponos;
import io.kiponos.sdk.configs.Folder;
import org.assertj.core.api.Assumptions;
import org.junit.jupiter.api.Test;

public class ExploreConditionalTest {
    static Folder cfg = Kiponos.createForCurrentTeam().getRootFolder();

    @Test
    void testAssumptions() {
        Assumptions.assumeThat(cfg.getBoolean("tests-enabled")).isTrue();
        System.out.println("Done");
    }
}

The Magic: while your CICD runs, whenever you change the "enable-tests" value online, the running tests will be skipped

Advantages and features of the Kiponos.io real-time service:

Role based access per team.
Manage runtime environments independently!
Same code, run on any env with matching SDK Key.
Forget about config files! totally!
- SDK detects your env var and Kiponos serves the correct config.
- You run local dev, staging, tests, production without a single config file!
- No more yamls, no more properties. Just code :)
- Mostly: You control and modify all envs independently.
Envs Hierarchy: change parent env value, and all child envs react instantly.
- For example, you have Staging as base config with max-queue-size = 500, Local Dev extends it having all that is defined in staging but overrides: max-queue-size = 12. Production overrides with 20000.
- More interesting - Non Dev teams can easily use the system. For example: Sales can define price plans in real-time and change rules without even restarting the servers! Marketing can change a logo URL or brand name - which will instantly affect all environments - dev,staging,production,cicd - all of them in real-time without even a refresh! because all is instantly dispatched and handled.
And that magic is totally free!

Enjoy the config revolution!

Signup at: Kiponos.io Signup

Kiponos.io Becomes Real-Time Hub

Devops Kiponos — Mon, 19 Jan 2026 17:55:22 +0000

Simple:

Any server gets Kiponos SDK.
SDK has get("key") and set(key, val);
Updates are dispatched using websockets instantly.

State is observable in real-time in Kiponos.io account.

Latest data is instantly updated as well on the web dashboard!

Enjoy!

Create Free Account Here

Watch Kiponos Config AI Insights Recommend Items

Devops Kiponos — Sun, 16 Nov 2025 16:00:13 +0000

Clicking the "AI Insight" button suggests config items tailored to your config node you currently work on.

In addition to the suggested config items, Kiponos suggests general insights relevant to your personal config context.

In the demo video, we see how the user creates the new "PostgreSql" config folder under "Database" and Kiponos AI suggests appropriate Postgres DB params plus general DB relevant insights.

Kiponos is a real-time config service, providing both Java and Python SDK based internally on permanent websocket connection with the server so your application works locally on the latest config data with zero latency.

With delta-update only and instant dispatch, you can modify any config item in real-time with no need to redeploy or restart your app. Everything is instantly updated while your app or server keeps running.

Grab your free account and SDK:

Kiponos.io
Java SDK (fully compatible with SpringBoot)
Gradle: implementation("io.kiponos:sdk-boot-3:4.4.0.250319")
Python SDK: pip install kiponos-pysdk

Disruptive: Kiponos AI Sidekick for App Configs

Devops Kiponos — Mon, 10 Nov 2025 02:01:47 +0000

Kiponos.io just published its new AI powers for all users!

Kiponos dashboard now analyze your config tree and suggest improvements.

Intelligently offering relevant new config items and optimized values right in the UI!

Just click the "Accept" button and boom! Your improved config is already available in real-time in your SDK.

Level up your stack today. Grab free access @ kiponos.io and let the Assistant work its magic.

Real-time, collab, centralized config combined with customized AI to your config tree brings unmatched config management.

First win? Spill in replies!

Ditch the Config Chaos: Meet Kiponos - the Real-Time Config Revolution You've Been Waiting For

Devops Kiponos — Wed, 05 Nov 2025 20:57:20 +0000

Picture this: It's 3 AM, your app's in flames because someone fat-fingered an env var in prod. Or worse—that "quick" config tweak forces a full redeploy, downtime ticking like a bomb. Sound familiar? We've all been there, wrestling with YAML nightmares, secret managers, and endless "it works on my machine" debates. Config management feels like herding cats... in the dark.

But what if I told you there's a better way? One that turns config into a living thing—shared, collaborative, and instant. Enter Kiponos.io: the ultimate config platform that's not just managing your settings; it's democratizing them.

The Aha Moment: Config That Breathes

With Kiponos, you forget env vars even exist. Instead, imagine this dead-simple line in your code:

// Java SDK (Spring Boot 2.x/3.x ready)
if (kiponosSdk.path("my-app", "debug").getBoolean("is-enabled")) {
    // Boom—debug mode flips on/off *live*, no restart needed
    logThatVerboseDebugInfo();
}

Or in Python:

# Python SDK—same vibe
if kiponos_sdk.path("my-app", "debug").get_boolean("is-enabled"):
    # Instant update from the web admin? It's already here.
    enable_debug_mode()

Here's the magic: Behind the scenes, your SDK stays glued to the Kiponos web app via a persistent WebSocket. Tweak a boolean (or any value) in the online dashboard—poof. Delta updates zip across in milliseconds. No full syncs, no latency lag. Your app (and every teammate's) just... knows.

The Power Unleashed

Multi-Env Mastery: Dev, Staging, Prod? Each gets its profile, with overrides that cascade like a boss.
Team Superpowers: RBAC locks down who touches what. Lock an item? It's frozen till unlocked. Everyone sees changes as they happen—real-time collab without Slack ping-pong.
Zero-Downtime Dreams: Toggle A/B tests, feature flags, or even API endpoints live. No restarts, no deploys. Just pure, seamless evolution.

This isn't incremental—it's a paradigm shift. Config becomes state control: Remote, collaborative, with virtually zero latency. DevOps? Streamlined. Developers? Liberated. Architects? Ecstatic (finally, a system that scales with human teams).

Kiponos isn't hype; it's the config nervous system your apps deserve. SDKs for Java (Spring Boot natives) and Python mean you're productive Day Zero.

Ready for your Aha? Head to kiponos.io and spin up a free account. Drop a config tree, flip a switch, and feel the future.

What's one config headache you'd nuke first? Reply below—let's geek out. 👇

Announcing Kiponos Python SDK v0.1.2: Real-Time Config as a Service for Python Developers

Devops Kiponos — Wed, 22 Oct 2025 21:16:50 +0000

Hey Dev.to community!

I'm excited to announce the release of the Kiponos Python SDK v0.1.2 on PyPI! Kiponos is a real-time configuration-as-a-service platform that lets you manage configs dynamically via simple SDK. Internally built on WebSockets and STOMP, Kiponos provides instant updates across environments in zero latency!.

It's perfect for AI apps, DevOps workflows, or any Python project needing zero-latency config changes without redeploys. without restarts. without even a refresh! Anything you modify online instantly affects your algorithm or any python app! simple as that!

Key Features

Real-Time Sync: Fetch the initial config tree and subscribe to delta updates (key created/updated) for instant reflection in your app.
Local Access: Configs stored in memory for fast lookups (e.g., client.get("learning-rate") or client.get("timeout") etc.
Secure & Isolated: Uses env vars for auth (KIPONOS_ID, KIPONOS_ACCESS) and supports profile paths for environment-specific configs.
Simple Integration: Connect, fetch, and query with minimal code.
No Code Modifications. No Config Files: Kiponos frees you from handling any config files or any static data, while your code is written only once - for all environments! all configs in any environment (dev, tests, staging, qa, production) are accessed seamlessly and managed by Kiponos.io in real-time.

Installation

Get started with:

pip install kiponos-pysdk

Requires Python 3.12+.

Quick Usage Example

Set up your env vars (from your Kiponos account):

export KIPONOS_ID="your-id"
export KIPONOS_ACCESS="your-access"

Then:

from kiponos_pysdk import KiponosClient

# work on specific config profile
client = KiponosClient(kiponos="['my-app']['1.0.0']['dev']['base']")
client.connect()

# Get a config value
print(client.get("timeout", "not found"))  # e.g., "100"

client.close()

For an interactive demo, check the repo for usage_example.py—it supports commands like get <key>, list-keys, dump, and exit.

Why Kiponos?

Built over 3 years of development, Kiponos decouples config from code, making your apps environment-agnostic. Free plans available—sign up at kiponos.io to get your tokens.

Feedback welcome! Source on GitHub: github.com/Avdiel/kiponos-py-sdk (soon public).

Usage Example - accessing real-time configs

import os
import time
import json

from kiponos_pysdk.client import KiponosClient

if __name__ == "__main__":
    # Expected env vars: KIPONOS_ID and KIPONOS_ACCESS
    env_profile = "['my-app']['1.0.0']['dev']['base']"

    kiponos_sdk = KiponosClient(kiponos=env_profile)
    kiponos_sdk.connect()

    print("\n\nWelcome to the Kiponos interactive example!")
    print(f"Team Id: {kiponos_sdk.team_id}")
    print("-------------------------------------------")
    print("Commands:")
    print("---------")
    print(" get <key_name>")
    print(" list")
    print(" dump")
    print(" exit")
    print(" help")

    while True:
        user_input = input("> ").strip()
        parts = user_input.split(maxsplit=1)
        command = parts[0].lower() if parts else ""

        if command == "exit":
            print("Stopping...")
            break
        elif command == "get" and len(parts) > 1:
            key_name = parts[1]
            value = kiponos_sdk.get(key_name, "Not Found")
            print(f"{key_name} = {value}")
        elif command == "list":
            keys = list(kiponos_sdk.config_tree.keys())
            print(keys if keys else "--- No Keys ---")
        elif command == "dump":
            print("Config Tree:")
            print(json.dumps(kiponos_sdk.config_tree, indent=2))
        else:
            print(f"Unknown command: {command}")

    kiponos_sdk.close()

[Boost]

Devops Kiponos — Thu, 16 Oct 2025 20:51:30 +0000

How Kiponos.io Ends Config Chaos in CI/CD

Devops Kiponos ・ Sep 10

#springboot #devops #firebase #kubernetes

Would you like Kiponos to have a Python SDK?

Devops Kiponos — Wed, 15 Oct 2025 19:33:23 +0000

Kiponos is the ultimate config solution - live config, in real-time, instantly affecting your app/algorithm on any modification you do online in your dashboard!

Kiponos supports Java SDK with full compatibility to SpringBoot.

Same way we revolutionized Java config management, we want to help Python developers and AI-Ops enjoy that config revolution and we think it will be extremely helpful to allow you guys to modify your AI algorithm params in real-time without restarting your algorithms or training processes.

For example, your training can continue to run while you adjust your parameters in real-time. live!

So, in order to be sure about the demand for a Python SDK, which we will publish fully for free as part of our free plan to all team sizes, please let us know:

Would you like a Kiponos Python SDK?

Any special request or suggestion for AI devs?

Thank you,
Moshe Avdiel,
Kiponos.io

How Kiponos.io Ends Config Chaos in CI/CD

Devops Kiponos — Wed, 10 Sep 2025 10:13:52 +0000

If you’ve ever built a Spring Boot app with application.properties, application-test.yml, application-prod.yml, environment variables tucked inside Docker containers, and CI/CD pipeline configs (Jenkins, GitHub Actions, GitLab, etc.)—you know the pain.

Every change to your pipeline usually means:

Updating some config file in your repo.
Injecting secrets or variables in Jenkins manually.
Redeploying to test if the “new” pipeline setting works.
Debugging why your staging branch builds differently than main.

It’s fragile. It’s messy. And it slows you down.

The Problem: Config Sprawl

In most Spring Boot projects today:

App configs → application.properties, profiles, environment variables.
CI/CD configs → pipeline YAML, Jenkins custom vars, Docker env overrides.
Test configs → special config files baked into branches or pipelines.

That means developers and DevOps must keep dozens of moving pieces in sync across environments. One wrong key, one stale config file, and your “green build” turns into a late-night rollback.

Enter Kiponos.io

Kiponos.io was built to end config chaos.

Instead of spreading config across files, YAMLs, and pipeline secrets, you get:

A Java SDK you drop into your Spring Boot app.
A real-time web console (like a futuristic control panel) where you define and change config.
Instant updates—your app and your pipeline pick up changes over WebSockets in real-time.

No redeploys. No restarts. No “switch branch and test config file.”

Real Example: Killing Test Config Files

Normally you’d do something like this in your Jenkins pipeline:

pipeline {
  environment {
    SPRING_PROFILES_ACTIVE = "test"
    CUSTOM_FLAG = "false"
  }
  stages {
    stage('Build') {
      steps {
        sh './gradlew build'
      }
    }
  }
}

And then in your Spring Boot app:

spring:
  profiles: test

custom:
  flag: ${CUSTOM_FLAG:false}

That means Jenkins → sets env vars → pipeline injects → Spring Boot picks up → test build runs.

Now imagine you need to flip CUSTOM_FLAG for staging only, or enable a temporary feature for a hotfix branch. You’re either editing Jenkins, or committing test config files into the repo.

With Kiponos, you just:

Open the Kiponos Web Console.
Find the custom.flag key.
Flip it to true.

Done. The pipeline and the Spring Boot app see it instantly.

No matter what branch is building, no matter which environment.

The SDK Side

Your Spring Boot app just uses the Java SDK like this:

import io.kiponos.Kiponos;

@Service
public class FeatureToggleService {
    static final Kiponos kiponos = Kiponos.createForCurrentTeam();

    public boolean isCustomFlagEnabled() {
        return kiponos.getRootFolder().getBoolean("custom.flag", false);
    }
}

That’s it. Your service is now wired to live config.

You don’t care if Jenkins, staging, or prod is running—the config lives in Kiponos, always up-to-date.

Why This Matters for CI/CD

One source of truth → no more drift between pipeline vars and app vars.
Instant change → flip a key in the web UI, pipeline behavior changes mid-build.
Branch-agnostic → no special config files per branch.
Zero redeploys → changes propagate live over WebSockets.

Instead of managing environment sprawl, you manage real-time config.

The Big Picture

We’ve been trained to accept that:

Configs belong in files.
Pipelines need manual tweaks.
Changing behavior requires redeploys.

But those are relics of the past. With Kiponos, configs are alive. They’re not tied to branches, YAML, or container layers—they’re real-time signals you control centrally.

So the next time your staging pipeline fails because of a missing env var, remember:
You don’t need more .properties files.
You need Kiponos.

👉 Try it now: kiponos.io

Kiponos added a real-time collaboration Task Manager tailored for programmers and dev teams.

Devops Kiponos — Thu, 14 Aug 2025 18:54:44 +0000

Configurations? Forget about it!

Devops Kiponos ・ Mar 25

#java #springboot #devops #configuration

Instead of Logs, notify your dashboard in real-time!

Devops Kiponos — Thu, 14 Aug 2025 18:46:05 +0000

Forget about logs to files or console!

Instead, send log messages directly to your online Kiponos dashboard! using the free Kiponos SDK.

As Kiponos internally dispatches your data using WebSockets, it is faster and safer then most log libraries and tools.

You got real-time messaging, with virtually zero latency!

For example,

You want some analytics or metrics report when you run tests.

Instead of logging, or even instead of reporting to a file, simply use the Kiponos SDK to "set" the keys and values at runtime like this:


   long totalOrdersCreated = 0;

   // Your counting logic....        
   totalOrdersCreated++;

   // Your SDK knows what's your team, runtime environment
   //    and config profile from the access token, 
   //    so no need to worry about initialization...

   Kiponos cfg = Kiponos.createForCurrentTeam();
   KiponosFolder usageStats = cfg.path("orders-stats");

   // Instantly displayed online in real-time on your dashboard.
   usageStats.set("total-orders-created", totalOrdersCreated);

Your Real-Time Web Dashboard

Any member of your team sees this in real-time on their dashboard:

Best,

Moshe Avdiel, Kiponos dev team.

Kiponos.io

Free Dev Teams Task Manager!

Devops Kiponos — Thu, 14 Aug 2025 15:39:57 +0000

Kiponos.io, the leading real-time config as a service, includes a real-time task collaboration tailored for programmers in their free plan.

How to use

SideBar --> Click "Task Mgr".

At the bottom, enter your "todo" task in free text!

A task card is dynamically constructed in real-time while you type!

Click save and it's added to your list.

Great for quickly adding tasks in the style of a quick note taking.

Features

The free text describing the task includes:

Associating TAGS for the task.
Estimation (and Due Date based on it).
Switch Dev Stages like: Research, Design, Code, Test, etc...
Simple Priority: High - Med - Low.
Filter by TAG combinations.
Filter by Priority.

Enjoy!

Kiponos.io