What is the best architecture for tackling monoliths, microservices, containers, AWS lambdas (functions), and serverless computing? Which applications must be deployed in the cloud, and which is the best strategy for on-premises deployments? Which are the most relevant (or not at all) Java frameworks to consider in this environment?
These are some of the questions that Adam Bien answers in this inspiring video called Java in the Clouds: From Monoliths to Serverless #slideless
More about Adam Bien
Adam Bien is a developer (Architect), consultant, trainer (https://airhacks.io), podcaster (https://airhacks.fm) and Java enthusiast . Be sure to check out his blog here. He uses Java since JDK 1.0 and JavaScript since LiveScript and still enjoys writing code. He also organizes Java / Web / Cloud / Architectures online live workshops https://airhacks.live and monthly Q&A live streaming show: https://airhacks.tv.
Serverless in Java explained
Even if it’s being replaced by other languages in many fields, Java is often (but not always) a good choice when it comes to developing serverless solutions supported by the main players in cloud (Azure and AWS). By going serverless, developers and architects can save time, effort and resources while a third-party provider handles details such as resources, scaling, runtimes, and security.
Every week we share videos from the Codemotion Watch platform. There you can find more than 1000 videos created by devs for devs with talks, edu paths, and playlists covering all aspects of the IT industry: from technical tutorials to inspiration, inclusion, and insightful career advice. Be sure to log in and check out the videos!
Going from a monolithic architecture to a serverless architecture with Java involves a significant shift in how your application is structured and deployed. I’ll explain the process step by step:
Understanding Monolithic Architecture:
Familiarize yourself with monolithic architecture. In a monolith, the entire application is built and deployed as a single unit. It typically consists of multiple modules or components tightly coupled together, sharing the same codebase, and running on a single server or cluster of servers.
Breaking Down the Monolith:
Identify the different components or services within your monolith that can be decoupled and function independently. These can be individual features or functionalities that can operate on their own.
Designing Microservices:
Refactor your application into a set of smaller, loosely coupled microservices. Each microservice should represent a specific functionality or feature, and it should have its own codebase, data storage, and APIs. Java frameworks like Spring Boot or Micronaut can be helpful in developing microservices.
Choosing a Serverless Platform:
Select a serverless platform that supports Java. AWS Lambda, Azure Functions, and Google Cloud Functions are popular choices. These platforms manage the infrastructure and allow you to focus solely on writing code for your functions or microservices.
Creating Serverless Functions:
Convert your microservices into serverless functions. Refactor each microservice into a separate function that can be executed independently. This typically involves defining a handler method that receives input and triggers the execution of your code.
Configuring Triggers and Events:
Determine the triggers or events that will invoke your serverless functions. Events can include HTTP requests, messages from a queue, changes to a database, or scheduled events. Configure your serverless platform to recognize and respond to these events, triggering the corresponding function.
Managing Dependencies:
When moving from a monolith to serverless, you may need to reorganize and manage your dependencies. Serverless functions should be self-contained, including only the necessary libraries and dependencies. Make sure to minimize the size of your deployment packages.
Deploying to the Serverless Platform:
Use the deployment tools provided by your serverless platform to upload and deploy your serverless functions. These platforms usually offer command-line interfaces (CLIs) or APIs to automate the deployment process.
Monitor and Scale:
Take advantage of the scalability benefits of serverless architecture. Serverless platforms can automatically scale your functions based on demand. Monitor your functions’ performance and utilize the monitoring tools provided by your chosen platform to gain insights and optimize resource allocation.
Iterate and Improve:
As you transition to a serverless architecture, keep iterating and improving your design. Serverless offers new opportunities for optimizing costs, improving performance, and leveraging additional serverless services like databases or caching solutions.
Remember that transitioning from a monolith to a serverless architecture requires careful planning and consideration of your application’s unique requirements. It’s essential to thoroughly test your serverless functions to ensure they operate correctly and efficiently in the new architecture.