Forem: Software AG Tech Community

Microservices Best Practices: Multi-Tenant microservices with Java SDK

Tech Community — Tue, 08 Oct 2024 11:22:16 +0000

Cumulocity IoT is a comprehensive IoT platform that enables device management, data collection, and analysis. The Cumulocity IoT Microservice SDK for Java allows developers to interact with the platform programmatically. Multi-tenancy is a key feature of Cumulocity, allowing multiple independent tenants to coexist on the same platform, each with their own set of resources.

Usage of Cumulocity IoT Microservice SDK for Java

The Cumulocity IoT Microservice SDK for Java can be used for a variety of tasks including device management, data collection, sending and receiving measurements, alarms, events, and more. It is designed to simplify the integration of devices and applications with the Cumulocity platform.

Multi-Tenancy in Cumulocity

Multi-tenancy in Cumulocity allows for the separation of data and resources for different tenants (organizations or users) on a single platform instance. Each tenant has its own space where devices, users, applications, and other resources are managed independently.

Use Case of Cumulocity Multi-Tenant

Objective: To effectively manage multiple tenants within a single Cumulocity IoT platform instance, ensuring data isolation, security, and efficient resource utilization.

Scenario: A global manufacturing company, “XYZ Industries,” operates in several regions worldwide, each with its own set of IoT devices, data requirements, and management needs. They want to use Cumulocity IoT to manage their devices, collect data, and perform analytics while ensuring that each region operates independently within the same platform.

Key Requirements:

Data Isolation: Each region’s data must be isolated from others to maintain privacy and security.
Customizable Dashboards: Regions need customized dashboards to monitor their specific devices and KPIs.
Scalable Services: The ability to scale services based on the number of devices and data load in each region.
Centralized Management: A central administrator should be able to manage global policies and settings while allowing regional administrators to manage their configurations.
Cost Efficiency: Optimize the use of resources to reduce costs by sharing the same infrastructure.

Implementation:

Tenant Structure:
Root Tenant: “XYZ”
Sub-Tenants:
- “North America”
- “Europe”
- “Asia”
- “South America”
- “Africa”
Features and Configuration:

Data Isolation: Each region (sub-tenant) has its own isolated data environment ensuring that data from “North America” is not accessible to “Europe,” and vice versa.
Customizable Dashboards: Regional administrators can create and customize dashboards tailored to their specific needs, showing relevant data, alerts, and analytics.
Scalable Services: The platform supports horizontal scaling to accommodate the varying number of devices in each region. Shared subscriptions allow for efficient handling of message loads.
Centralized Management: The central administrator at “XYZ” (root tenant) can define global policies, security settings, and shared services. Regional administrators manage local devices, users, and configurations.
Cost Efficiency: By using a multi-tenant structure, “XYZ” reduces infrastructure costs while maintaining flexibility and scalability for each region.

Benefits:

Efficient Resource Utilization: Shared infrastructure reduces overall costs while maintaining high performance and reliability.
Enhanced Security: Data isolation and customizable security policies ensure that each region’s data remains secure and private.
Scalability: Scaling services based on regional demand allows for efficient resource management.
Flexibility: Each region can operate independently with its custom configurations while adhering to global standards set by the central administration.
Centralized Control: Global policies and settings can be managed centrally, ensuring consistency and compliance across all regions.

Conclusion: The use of Cumulocity’s multi-tenant capabilities allows “XYZ Industries” to efficiently manage their global IoT operations, providing each region with the tools and autonomy they need while maintaining overall control and optimizing resource use.

Available Methods within Cumulocity IoT Microservice SDK for Java

The Cumulocity IoT Microservice SDK for Java provides a comprehensive set of APIs. Some of the key APIs and their methods include:

MicroserviceSubscriptionsService : Main entry point to the tenant as microservice gets subscribed on a tenant.
- callForTenant(String var1, Callable<T> var2): Within this method any Cumulocity Java SDK API could be called for a specific tenant if a message needs to be returned.
- runForTenant(String var1, Runnable var2): Within this method any Cumulocity Java SDK API could be called for a specific tenant if nothing is returned
- runForEachTenant(Runnable var1): Within this method any Cumulocity Java SDK API could be called for all the subscribed tenants and nothing will be returned.

Example of Multi-Tenancy with Cumulocity IoT Microservice SDK for Java

Here’s an example of how you might interact with different tenants using the Cumulocity IoT Microservice SDK for Java:

Setup

Add the Cumulocity Microservice SDK for Java to your project. Ensure you have the SDK dependency in your pom.xml if you are using Maven:

<dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>com.nsn.cumulocity.clients-java</groupId>
                <artifactId>microservice-dependencies</artifactId>
                <version>${c8y.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
</dependencyManagement>
<dependencies>
        <dependency>
            <groupId>com.nsn.cumulocity.clients-java</groupId>
            <artifactId>microservice-autoconfigure</artifactId>
            <version>${c8y.version}</version>
        </dependency>
</dependencies>

Create a client for all the subscribed tenants :

 subscriptionService.runForTenant(tenantId, ()-> {
            try {
                //Do the Cumulocity API call for the specified tenant
            }catch(Exception e) {
                //log the error message
            }
        });


return subscriptionService.callForTenant(tenantId, ()-> {
            try {
                 //Do the Cumulocity API call for the specified tenant and return the result
            }catch(Exception e) {
                 //Log the error message as well as return the same
            }
        });


subscriptionService.runForEachTenant(() -> {
        try {

               //Do the Cumulocity API call for each subscribed tenant

        } catch (SDKException exception) {
               //log the error message
        }
    });

Advantages of Multi-Tenancy

Resource Isolation : Each tenant’s data and resources are isolated, ensuring privacy and security.
Scalability : Efficiently manage multiple organizations or projects on a single platform.
Cost Efficiency : Reduce infrastructure costs by sharing resources among multiple tenants.
Simplified Management : Centralized management of multiple tenants with easy maintenance and updates.

Conclusion

The Cumulocity IoT Microservice SDK for Java provides a robust framework for managing IoT devices and data in a multi-tenant environment. Its comprehensive APIs simplify the development process, allowing for efficient and secure management of multiple tenants. Understanding the advantages, limitations, and available methods will enable you to leverage the full potential of the Cumulocity platform in your IoT projects.

Read full topic

Scaling Micro-Frontend Reliability: Advanced Techniques in Version Management and Automated Testing

Tech Community — Mon, 30 Sep 2024 11:05:38 +0000

Introduction

This article is a follow-up to The power of micro frontends – How to dynamically extend Cumulocity IoT Frontends. Since the original publication, significant changes have occurred, with an increasing number of plugins being created by both Cumulocity teams and the community. As the use of micro frontends within the Cumulocity platform grew, new challenges emerged. One of the most frequently mentioned issues in the micro frontend space is dependency version incompatibility. We’ve addressed this challenge using a set of metadata called the version matrix and Cypress tests. But first, let’s look at what’s changed…

What has changed since the first micro frontend article?

A major update to our Web SDK was the deprecation of the @c8y/cli package. It has been replaced by the @c8y/devkit package, which now serves as a builder for ng-cli. In simpler terms, instead of handling all commands through our own CLI, we now extend Angular CLI. This means you don’t call @c8y/devkit directly; instead, all commands start with ng <command>. For more information about ng-cli, check out the Quickstart section.

Another change is that you no longer declare your exports in package.json. Instead, they are now defined in cumulocity.config.ts (which is later compiled to cumulocity.json).

If you’re ready to build your own plugin, refer to the Microfrontends documentation for detailed, step-by-step guidance on creating a plugin.

Version matrix

Introduced in Web SDK version 10.19.0, the version matrix is a part of the plugin designed to ensure compatibility between the plugin, Web SDK, and shell API. To use it, simply add it to your cumulocity.config.ts file.

Here’s an example of how a version matrix might look (content of cumulocity.config.ts):

export default {
  runTime: {
    ...
    versioningMatrix: {
      '2.1.6': {
        sdk: '>=1016.0.0 <1018.0.0',
        api: '>=1016.0.0 <1018.0.0',
      },
      '3.2.1': {
        sdk: '>=1018.0.0',
        api: '>=1018.0.0',
      }
    },
  },
  buildTime: {
    ...
  }
} as const satisfies EnvironmentOptions;

The top-level keys (2.1.6, 3.2.1) represent the plugin versions, while the sdk and api values specify semver ranges of compatible Web SDK and API versions, respectively.

To illustrate how the version matrix works, let’s try installing version 3.2.1 of a plugin with the above matrix into Cockpit version 1017.0.543. You’ll receive this warning:

As you can see, you can still install the plugin, but you’re warned that versions might be incompatible. Some features might not work, or the plugin could fail to load and potentially break your app. This warning won’t appear for Cockpit version 1018.0.0 or higher.

E2E testing plugins against shell

While the versioning matrix works almost effortlessly when properly declared, how do we determine which versions are compatible with our plugin? Manual testing is always an option, but it’s time-consuming and prone to human error.

This concern led us to develop a solution that informs us about incompatibilities between our plugin and the shell app.

Cypress to the rescue!

The most effective way to ensure our plugin works correctly with a particular shell app (without hiring a new QA specialist) is through end-to-end (E2E) tests. For this type of testing, we use the Cypress library along with cumulocity-cypress and cumulocity-cypress-ctrl packages, developed by our team.

We chose our Cumulocity community plugins repository to introduce this feature. The plan was straightforward - we introduced a new workflow that:

1. Collects shell versions

First, we need to decide which shell versions to test our plugin against. For this purpose, we created the plugins-e2e-setup repository containing a custom Github action collect-shell-versions. This action provides information about the latest versions for relevant distribution tags. By default, it returns the last 3 yearly release tags (and if there aren’t 3 yearly releases yet, it also includes the 1018.0-lts tag). Here’s an example result of this action:

[
  { "tag": "y2025-lts", "version": "1020.26.2" },
  { "tag": "y2024-lts", "version": "1018.503.119" },
  { "tag": "1018.0-lts", "version": "1018.0.278" }
]

2. Builds the plugin

An obvious step - we need to build the plugin to run it in the shell in later steps.

3. Gets shell apps, hosts them, and runs E2E tests

Now that we know which shell versions we want to test our plugin against, we need to obtain builds of these apps. In our previously mentioned plugins-e2e-setup repository, we have a second custom Github action - get-shell-app. This action downloads the build of the requested app (Cockpit, Administration, or Device Management) for the specified version.

With both the shell and plugin apps in hand, we can use cumulocity-cypress-ctrl to host the apps, run Cypress test suites, and verify if the plugins are usable in the shell apps.

Usage of the workflow

Currently, we run this workflow in two scenarios:

On each pull request
Scheduled with CRON for nightly runs

The first use case helps us detect incompatibilities mainly due to changes in the plugin itself.

If tests fail, the actions that can be taken are:

If tests fail because test suites are out of date - update the tests
If tests fail because the plugin is not compatible with some shell versions:
- Update the versioning matrix to indicate compatible Web SDK versions and align the workflow to test against relevant shell versions
- Or review the changes and select a different approach to ensure plugin compatibility with the shell

While the first use case is mostly relevant to recent changes in the plugin, the second use case targets changes in the shell app. Even if a new plugin version hasn’t been released for days or weeks, the workflow is triggered every night, and tests are run against current versions of the shell app.

Thanks to these scheduled runs, we can receive notifications if a new version of Cockpit is not compatible with our plugin, allowing us to take the actions mentioned above.

Of course, it doesn’t make sense to test the same version of the plugin with the same version of the shell repeatedly. That’s why our CRON job creates a cache of test results, so if no new version of the plugin or shell is released, the test case can be skipped.

The power of `cumulocity-cypress-ctrl`

You might wonder why we use the cumulocity-cypress-ctrl package instead of simply using the http-server package to host the shell and plugin, letting Cypress handle running test suites. There are several compelling reasons. Read full topic here to find out what they are.

IoT Tech Talk - Cumulocity IoT & Machine Learning

Tech Community — Thu, 05 Sep 2024 10:59:44 +0000

Overview

In this IoT Tech Talk, Dr. Kanishk Chaturvedi, Solution Architect, Software AG and Nick Van Damme, Product Manager Analytics, Software AG talk about how Machine Learning (ML) and Cumulocity can be combined to implement powerful use cases.

Resources

Read full topic

Achieve application high availability in a distributed architecture | IUG 2024

Tech Community — Thu, 22 Aug 2024 11:55:24 +0000

About this video

Maximize the uptime of your business applications with the new Natural Availability Server. Learn how to achieve high availability and seamless failover for Natural apps in Linux and cloud environments.

Read full topic

Make Adabas on Linux more resilient | IUG 2024

Tech Community — Thu, 22 Aug 2024 08:28:43 +0000

About this video

What’s the importance of making Adabas more resilient in Linux environments? Join us for this presentation as we compare old monolithic designs found in mainframes to modern multi-instance and distributed models, stressing the latter’s advantages in dealing with serious incidents and disasters.

Read full topic

Secure Adabas on Linux | IUG 2024

Tech Community — Wed, 21 Aug 2024 08:39:33 +0000

About this video

Discover how to use encryption, role-based access control (RBAC) & other tools to maximize your Adabas data’s security on Linux platforms.

Read full topic

Adabas & Natural innovations | IUG 2024

Tech Community — Tue, 20 Aug 2024 11:10:39 +0000

About this video

Evolve your applications to be future-ready, now! Discover how the innovations of the Adabas & Natural 2050+ agenda enable you to embrace the latest advances in high availability, security, hybrid cloud, platform optimization, and much more.

Read full topic

What does Zero Trust Security mean for you | IUG 2024

Tech Community — Mon, 19 Aug 2024 11:53:22 +0000

About this video

You’ve heard the buzz! More and more enterprises are requiring Zero Trust as their new security architecture. What does this mean to you? We describe the principles and components of Zero Trust and the many capabilities that can be used to support Zero Trust in an Adabas & Natural setting.

Read full topic

Innovation, Modernization & the journey to Agility | IUG 2024

Tech Community — Mon, 19 Aug 2024 07:52:12 +0000

About this video

Learn how the Virginia Department of Motor Vehicles is using NaturalONE to modernize the development of mainframe apps utilizing agile, scrum, and sprints. Using APIs, VA can generate mobile driver licenses and “talk” to all states and the federal government using a common interface.

Read full topic

Maximize your cost saving with zIIP offloading | IUG 2024

Tech Community — Fri, 16 Aug 2024 10:40:40 +0000

About this video

The mainframe’s significance in terms of stability, performance, and security is unquestionable. However, keeping infrastructure expenditures under control is an ongoing concern. Learn how to improve your mission-critical workloads, such as Natural with Db2, and make use of IBM zIIP processors.

Read full topic

Junior Developer's Guide to Legacy Systems | IUG 2024

Tech Community — Fri, 16 Aug 2024 07:07:08 +0000

About this video

Developers Lars-Erik Bjørk, Kristoffer Jacobsen, Geir Knudsen, and Johan Svartdal present their insights on organizational change and onboarding new talent.

Read full topic

IT Outages, how can they be avoided?

Tech Community — Tue, 30 Jul 2024 09:47:53 +0000

By Ilan Hirschowitz, Senior Adabas & Natural Customer Success Architect, Software AG, 30 July 2024

What happened in simple terms?

Friday, July 19th was a bad day worldwide and the week after wasn’t much better. A bug in a critical security component that was rolled out caused havoc around the world. Not since the doomsday predictions of Y2K | BUG 2000, which was supposed to have widespread dire consequences, has such an event affected our planet with banks, airlines, and major institutions having severe systems outages. At least with Y2K, companies were anticipating the risk—I recall reaching out to our Australian colleagues at midnight just to confirm that all was okay. This one hit the world completely by surprise.

The error messages 0x50 or 0x7E appear on a blue screen and the computer goes into a looping restart state. This renders the Windows terminal unusable. A SPOF or single point of failure can become any company’s biggest nightmare.

Companies normally have automatic updates turned on, so this bug was propagated unwittingly to all their servers on that Friday.

Who was affected?

Microsoft estimated that about one percent of worldwide Windows devices, around 8.5 million servers, were impacted by the bad release update. This figure sounds small but there were many more connected applications that were affected and became non-functional meaning many more end-users could not work. The airline industry was possibly the most visible victim since some airlines reported that upward of half of their IT systems are Windows-based.

Being robust, our customer’s Adabas & Natural mainframe applications were not directly affected by the outage. Still, systems may have been unreachable if endpoint connections off the mainframe were not available.

Why is it so difficult to fix?

A manual intervention by an IT specialist is needed since there are multiple steps to go through that an end user would find difficult to perform. The steps involve starting Windows in safe mode & deleting the offending file. Because the Windows machines are offline, the IT specialist needs to physically sit in front of every machine to perform the recovery, a time-consuming task.

You may ask, how can one avoid this?

One way is to have Point in Time (PIT) encrypted backups stored in a secure vault.

Both for Cyber malware attacks and for inadvertent Software bugs, PIT backups allow you to revert to a state before the attack or bug.

A cloud-based solution could also help where after fixing the underlying problem, new servers could be easily provisioned and spun up quickly, even though the old ones were unavailable.

How can a robust cluster solution protect your mission-critical databases?

If you rely on an Adabas database, you have another way to recover from an outage. Software AG’s Adabas Cluster for Linux solution allows a transparent failover mechanism for any Adabas database outage under Linux. When it comes to patching, each individual node is taken out of the cluster & each is patched separately without affecting the health of the remaining cluster nodes. If one node gets a bad update, then the others continue to function as normal. This is also critical in preventing common single points of failure scenarios. The same holds for our mainframe Adabas Cluster Services which takes advantage of a z/OS® Sysplex cluster.

This has several advantages such as high availability, robust disaster recovery, scalability, and efficient isolation of systems in the Sysplex from others, providing a secure environment for different applications.

Finally, this also solves the patching and SPOF issues.

Hopefully, some simple preventative measures such as these will allow DBAs and IT Admins to sleep better at night!

Learn more about Adabas Cluster for Linux | Software AG

Read full topic

Forem: Software AG Tech Community

Microservices Best Practices: Multi-Tenant microservices with Java SDK

Usage of Cumulocity IoT Microservice SDK for Java

Multi-Tenancy in Cumulocity

Use Case of Cumulocity Multi-Tenant

Available Methods within Cumulocity IoT Microservice SDK for Java

Example of Multi-Tenancy with Cumulocity IoT Microservice SDK for Java

Setup

Advantages of Multi-Tenancy

Conclusion

Scaling Micro-Frontend Reliability: Advanced Techniques in Version Management and Automated Testing

Introduction

What has changed since the first micro frontend article?

Version matrix

E2E testing plugins against shell

Cypress to the rescue!

1. Collects shell versions

2. Builds the plugin

3. Gets shell apps, hosts them, and runs E2E tests

Usage of the workflow

The power of cumulocity-cypress-ctrl

IoT Tech Talk - Cumulocity IoT & Machine Learning

Overview

Resources

Achieve application high availability in a distributed architecture | IUG 2024

About this video

Make Adabas on Linux more resilient | IUG 2024

About this video

Secure Adabas on Linux | IUG 2024

About this video

Adabas & Natural innovations | IUG 2024

About this video

What does Zero Trust Security mean for you | IUG 2024

About this video

Innovation, Modernization & the journey to Agility | IUG 2024

About this video

Maximize your cost saving with zIIP offloading | IUG 2024

About this video

Junior Developer's Guide to Legacy Systems | IUG 2024

About this video

IT Outages, how can they be avoided?

What happened in simple terms?

Who was affected?

Why is it so difficult to fix?

You may ask, how can one avoid this?

How can a robust cluster solution protect your mission-critical databases?

The power of `cumulocity-cypress-ctrl`