Sunil Mallesara

Hi. This is Sunil Ghor. I'm a principal engineer in the Australian Stock Exchange, working remotely in Bangalore. I have around 15 years of experience, entirely in the Java domain. I've been working as a Java developer right from the beginning of my career. Right now, I'm working as a principal engineer with my day-to-day activities involving system design, requirement analysis, coding, and code reviews. I'm also responsible for team management. A typical day starts with the SCUM meeting, where we discuss day-to-day progress, blog posts, and how actively we can engage with each other to decide what should be prioritized and work on the same. This is my current profile, at a very brief level.

To design a scalable and secure API endpoint, we need to start by identifying the kind of data it is processing. And depending on the level of processing it needs, we can identify the microservices it requires. If it can be distributed among different microservices, we can scale up using our cloud infrastructure. That would be one approach I would prefer for addressing the scalability of any application. And when it comes to the secure API endpoint, we can explore using token certifications or making the API available only to authorized users or applications.

If we are converting a Java application into a microservice architecture on Kubernetes, the very first thing is to understand what this application is doing. We have to understand how many different kinds of operations it is doing, depending on which we can actually segregate independent sets of operations and group them into microservices. And then, I'll make them deployable on our Kubernetes cluster. So, this is how we can start changing the design of our application. This would be the very first step. And then, coming on to the Kubernetes architecture, we can always think about deploying on a port and having the customer manage this port, and the backup strategy and failure strategy can be defined on the Kubernetes. This would be my approach to start thinking about converting a monolithic Java application into a microservice architecture on Kubernetes.

If we have to design a scalable real-time data pipeline, AWS offers several capabilities that can help us address our issues for minimal latency and data loss. We would need to follow the best practices on AWS and utilize the available features to define our strategy. I'm not able to give the exact solution at this stage, but I would start by reading through the AWS capabilities on this front to address data.

If we are migrating, refactoring the last code base from Java to Scala, I would start from scratch. I would take one thing at a time and identify the services which can be taken independently of the remaining part of the codebase. So, convert our refactor once at a certain time, and upgrade each of these. Stage by stage, make sure dependent areas are upgraded together so that there won't be any much downtime in terms of upgrading these services.

Yes, again, coming to AWS. I have limited working experience with AWS. Now I have a very good experience with GCP. So, to answer questions for AWS, I would definitely start looking at the similar options that we have and then identify the corresponding solution on AWS. There is always a lot to consider in which I'll

To ensure high availability and disaster recovery for a distributed application on AWS, we have many features that make sure the higher availability. We have the availability zones, which will address high-level availability. If some of the zones are down for some technical issues, the surface on the other availability zone would back it up and then make sure there is no performance impact or downtime. And in case of disaster recovery as well, if there is some region that has a major disaster, it could be measured as earthquakes. So, now the remaining available data zones will pick up the request and then scale up to address the issue.

We are assigning a null interpretive data type Paint. I think we can go with the default value of 0 instead of assigning it now.

To monitor and auto-scale a Java application within the Kubernetes ecosystem, I would use cluster management to manage.

To optimize JV's JVM performance for a Java application in a containerized environment, I would look for the memory consumption from the application during the application runtime. So if it's using a heavy number of objects at the same time, I would look at optimizing the load by looking at the parallel executions. If there is no other way, we'll have to increase the memory. Otherwise, we can always refactor the code to make sure what can be executed can be sequentialized.

AWS provides CloudWatch to track the application health. We can integrate into the AWS services to ensure there are relevant alerts and backup steps that we can take in case of any application going down. So, AWS provides robust features which can be leveraged to manage our applications and their

I'm happy to help with the transcript.