Sudipta Chanda

Hello, my name is Sridipto Chandu and I have been working as a developer for the past nine years. Currently, I work for Oracle. My designation is project lead. So, basically, I have been using microservices in the back end for quite some time, almost six years now. I have used Spring Boot earlier, but currently, I am using the Halidane framework to build microservices. Our architecture is basically event-driven. So, we are using Oracle Streaming Service, which is similar to Kafka for messaging purposes. The communication between our services is through messaging. We also have Maven as our build tool, deploy through Jenkins, Docker files created for all of our services, and we use Helm charts in Kubernetes to deploy in Oracle Cloud currently. For Java version, I am currently using Java 20 and 21, and in some places, Java 17. I am quite well-versed in Java. That's pretty much it; I have been working as a back-end developer for a long time.

Okay, so the question if I understand correctly is how can we integrate Python in Java based microservices and potential pitfalls, potential pitfalls means like the negative side, okay. So what I can think of right now, so integrating Python into Java based microservices scenario is basically called polyglot architecture. So it's simple, like, wire services are written in different languages but basically get connected over a network connection. So it's like basically HTTPS connections, we can use that. So like my, I mean, what I understand is basically like if we have, let's say, two different microservices, one is written in Java and one is written in Python, I mean, we can basically communicate between each of these services using HTTP. And that's pretty simple, like we can use Spring Boot for Java and normal HTTP calls for Python, like normal API router stuff like that. So what are the potential pitfalls that I can think of that can happen? So I mean, one pitfall I can think of is network latency, like basically between service communication, there could be some latency that comes into the picture. So and then another problem might be error handling, like timeouts and stuff like that, socket timeouts and stuff like that, because both of the services are in different languages, we have to manually add those to our services to handle the situation. And the third would be data serialization could be a big factor, I guess, because one particular data that can get serialized from Java to Python to deserialize that in Python might take some more time, sometimes it gets overwritten. And the last, I would say, like the versioning, I think both API versions have to be the same or something like that. And basically, we can integrate using message queues also, message queues will be easier to use, like we can have something like Kafka or something like that, one particular microservice produces the message and the other one listens to that particular message and uses that. It can be RabbitMQ, Kafka, or something similar.

Caching mechanism in Spring Boot distributed system. So, like simply at first what can I think of is that caching basically makes your services work very fast. So, the data can easily make all the services very fast. There are two different types of caching we can use: local caching and distributed caching. Local caching is where the caching will happen inside the application memory directly. However, if we have multiple microservices and instances running for the services, it can create trouble because caching would not be useful in that case, as it will not be distributed between the systems. So, the best case scenario I think is to use distributed caching, like Redis or something like that, because Redis is an in-memory system and will be much faster. There are other alternatives like Memcache, Hazelcast, and stuff like that, but I think Redis is well-known and well-documented, and will be much easier to use. To use Redis, we basically need to have a Redis service running in our cluster. We then push whatever data we need to cache to the Redis queue, and different services can read it from there first, trying to get the data from the cache and then do the usual mechanism if it's not there. In Spring Boot, we need to have a configuration class for Redis and then use that. That's pretty much it.

Okay, so I can based AI model, so into Java, so I can integrate between if we have a AI model in Python and then we need to integrate in Spring Boot application, how can we do that? I think like the best way to approach it is like event-driven, so I mean the easiest way I can think of is RESTful API, like normal RESTful API, then we can use like messaging queue also is fine. We can use like gRPC connections also, but I mean, yeah, that is possible and we can use like something like JVM, but that JVM based Python, but that's not very useful. I think the best way to use is like normal API, like REST API calls, gRPC and message queue. I think these are the best three ways to connect basically, and like the simplest way to do this is basically we will from the API send the data, like data to the Python and get the data from the AI model, whatever data that is, and whatever the prediction from the AI model is, and then send it back to the API. That's the idea for basic API calls. Same thing we can do for message queue also, is basically we send one particular information, like whenever a Spring Boot API is, Spring Boot service is sending a certain kind of message to the message queue, and then it's getting read by the Python and do some work on that, the AI model basically, and create a JSON body of the prediction and send it back to the message queue. And then we have the Java client and then read it and do some processing on that. So I think, yeah, that's pretty much, and gRPC is the same way, basically one, like it has to come from the Java service and then go to the Python, and then Python will return with some answers, that's as simple as that. So, I mean, in yeah, I think that's pretty simple because I think Python has some specific libraries for this kind of operations, like I think Jython is there and Py4J. So this will be useful, actually.

When a method using Java to prevent overloading a microservice during peak traffic time. Outline a method using Java to prevent overloading a microservice. I would say create a rate limiter or something in a minute we can basically have a separate service that service will check how many calls a particular service is getting and if it peaks more than 30 or 40, whatever the requirement is, then we can stop that call and say request after a certain period of time or something too much pressure. So I think it's very simple, for the rate limiter service we will have a Redis cache and save the call instances over there, and with the time for every minute we will save the data and check that it's more than the threshold or not. If it's more than the threshold, then we'll cut all the calls to the particular service from the rate. That's much more scalable and easy to implement, I think that's the best approach. We will need some extra memory for that, obviously, for the rate limiter we will have to have a database to save the data and a caching mechanism also to save the time. We will save the requirement in the database and read it from our service and then check from the Redis cache how many if it is matching in our cache it will be faster also.

How to implement Python-based feed to automate health checks across network of Spring Boot? Python-based. How to implement Python-based feed to automate health checks across network of Spring Boot? How to implement Python-based feed to automate health checks across network of Spring Boot? How to implement Python-based feed to automate health checks across network of Spring Boot? How to implement Python-based feed to automate health checks across network of Spring Boot? How to implement Python-based feed to automate health checks across network of Spring Boot? How to implement Python-based feed to automate health checks across network of Spring Boot? How to implement Python-based feed to automate health checks across network of Spring Boot? How to implement Python-based feed to automate health checks across network of Spring Boot? How to implement Python-based feed to automate health checks across network of Spring Boot?

Java snippet below. Can you identify the problem with the singleton design but an imprimatur here suggest how to read issues in multi-faceted? Yeah because In this particular snippet. We are not using synchronized block basically to Make a lock on the gate instance method because if there are multiple Thread are running in this particular situation It can create like multiple instances because it's not set. So to make it Let's say we basically have to have like a synchronized block. We can use synchronized block on the method Signature like the definition also we can have like basically after that. We are checking the instances now We basically have like the synchronized block inside that and after that we can check the instance is null or not And then basically we can return the classes instance From this then it will be safe in threats in multi-faceted environment. And I think that's the best approach for singleton Because I mean other than that I would say like everything is fine because we are having like a private constructor and We are returning the instance directly. So yeah, I think that's basically just use like synchronized block Inside the method or at the top of the method for the gate instance, that's

Review the block of Java code for RESTful service. Can you spot the issue that might arise from the exception handling? Can you spot the issue that might arise from the exception handling? Can you spot the issue that might arise from the exception handling? Can you spot the issue that might arise from the exception handling?

Devise a method to ensure consistent data across multiple microservices, ok. So, I think the best way I understand from this information is basically we have multiple microservices and then data flows from one service to another and then another. Then I think in this particular situation, we just need to make sure that the data coming from all different databases are consistent and basically proper. If something fails in one of the microservices, it actually shows in the database for all different sets. I mean I think the proper way to handle that is we can use a design pattern in microservices for Saga design pattern. It is very effective. We can have an event-driven architecture like an orchestrated one. So, in this situation, particularly if one data comes from another service to another service, we basically have a success or failure scenario. So, if the next microservices successfully process the data, we basically send a successful message to the previous microservices. I mean to the messaging service, and that particular message is read by the previous microservices and basically it commits the data. If it fails, basically it rolls back the old data, whatever it was committed to that earlier data. So, in that way, we basically have a way to go back easily between microservices if something fails. The other way is to use a layer after all the services get the data, an orchestrated layer or something like that, where we get all the data from the database from all the services and basically do the processing over there in a single transaction. So, if something fails, we can roll back easily. So, in that way, like there will be no failure situation. So, I think that should be fine. I mean I think that's the best way to approach. The first one is the two-phase commit, where basically we do the commit first and then let the data go and then keep checking if something fails, and from a messaging service or something, we send the data information back to that service and do the processing based on that. And then the orchestration layer is basically much simpler in a single transaction block, we do get all the data from all the different microservices and do the transaction. Yeah, that's it.