The 6 Rules for Modernizing Your Legacy Java Monolith with Microservices

•

30 likes•9,429 views

We change a monolithic system only when we have no other choice. Traditional enterprise systems are tightly-coupled; all-in-one, all-or-nothing, difficult to scale, difficult to understand and difficult to maintain. Rather than swiftly capture opportunity, we ponder if it’s really worth it—is it worth upsetting the delicate balance of the house of cards we call our enterprise system? Often the opportunity quickly disappears, captured by a faster company. Some people have started calling this “Getting Ubered”. So what can you do about it? Talking about Microservices is one thing, but how can your organization start taking action to address this issue? In this webinar by battle-hardened Enterprise Advocate, Kevin Webber, we walk through the 6 key concepts to understand as a guide for taking action: 1. Domain Driven Design (DDD) 2. Asynchronous messaging 3. API management 4. Dependency management 5. CQRS & event sourcing 6. Transactions & ordering Reactive Platform has what you need to breath new life into your legacy system with a new Microservices-based approach.

Software

The 6 Rules for Modernizing Your Legacy
Java Monolith with Microservices
by Kevin Webber (@kvnwbbr)

heritage
architecture
» Single points of failure
» Impossible to scale out
(shared mutable state, etc)
» Different non-functional
requirements (reads,
writes, compute)
» Optimized for none!
» Long, risky release cycles

Microservices
» Ubiquitous language
» Well deﬁned models &
boundaries
» Single responsibility
» Independently deployable,
scalable, resilient
» Communicate via async
messaging
» Own their data
» Don't expose a public API

Approach?
Principles
» responsive, resilient,
elastic, message-driven

Approach?
Principles
» responsive, resilient,
elastic, message-driven
Concepts
» bounded contexts (DDD),
event sourcing, CQRS, CAP
(eventual consistency)

Conceptsand patterns
We will cover:
» Domain Driven Design (DDD)
» Async messaging
» API management
» Dependency management
» CQRS & event sourcing
» Transactions & ordering

Getting started
» Model sub-domain at package
level
» Tip: Visualize existing
architecture with a tool
like Structure101
» Deﬁne public RESTful API
at package level (use async
messaging inside package at
service level)
» Refactor for physical
separation, remove package

Async Beneﬁts
» Not wasting resources
» Memory, CPU, threads
» Embracing failure
» Not expecting a return
from a remote service
» Designing for all
scenarios

API mgmt.
» Messaging patterns
» Pub/sub, point-to-point,
streaming
» API gateway
» Routing, aggregation,
protocol translation
» Discovery
» Service discovery,
registry, versioning

Considerations
» ACID doesn't work across location/trust boundaries
» No 2-Phase commits (2PC)
» No holding locks for the duration of work
» In distributed systems we need to compensate for
for failure rather than prevent failure

Microservices
with Lightbend
» Play for API gateway
» Akka for core microservices
(DDD, CQRS, event sourcing)
» ConductR for cluster
management (service
registry, discovery,
architecture visualization,
security)

Lagom
Monolithto microservices
» Webinar: March 17, 1PM PST / 4PM EST
» https://www.lightbend.com/discover-lagom
» Ready-to-use connectors: event-sourcing, CQRS
» Launch all microservices with a single command
» Instantly visible code updates

Thankyou!
Visit https://www.lightbend.com/products/lightbend-
reactive-platform to get started
Contactinfo
» Twitter: @kvnwbbr
» Email: kevin.webber@lightbend.com

LIGHTBEND REACTIVE PLATFORM 
Full Lifecycle Support for Play, Akka, Scala and Spark
Give your project a boost with Reactive Platform:
• System orchestration for resilient releases
• Real-time monitoring of asynchronous systems
• Self-healing for network partitions, node and apps
• Availability protected with configurable user quotas
• Certified, load-tested Reactive Runtime
Enjoy learning? See about the availability of
on-site training for Scala, Akka, Play and Spark!
GET STARTED

The 6 Rules for Modernizing Your Legacy Java Monolith with Microservices

Having a team adopt new technologies and approaches to software development is a daunting task. New paradigms and unfamiliar ontologies headline the biggest risks to having a team be productive quickly. Lightbend (formerly Typesafe) has a suite of training classes to help you adopt whatever components of the Lightbend Reactive Platform you need to be responsive to you customers by creating resilient and elastic applications. In this webinar, we will discuss the philosophies and structures of Lightbend's training materials for Scala, Akka, Play Framework, and Spark.

Nine Neins - where Java EE will never take you

Markus Eisele

Virtual JUG Session: http://www.meetup.com/virtualJUG/events/232052100/ With Microservices taking the software industry by storm, classical Enterprises are forced to re-think what they’ve been doing for almost a decade. It’s not the first time, that technology shocked the well-oiled machine to it’s core. We’ve seen software design paradigms changing over time and also project management methodologies evolving. Old hands might see this as another wave that will gently find it’s way to the shore of daily business. But this time it looks like the influence is bigger than anything we’ve seen before. And the interesting part is, that microservices aren’t new from the core. Talking about compartmentalization and introducing modules belongs to the core skills of architects. Our industry also learned about how to couple services and build them around organizational capabilities. The really new part in microservices based architectures is the way how truly independent services are distributed and connected back together. Building an individual service is easy with all technologies. Building a system out of many is the real challenge because it introduces us to the problem space of distributed systems. And the difference to classical, centralized infrastructures couldn’t be bigger. There are very little concepts from the old world which still fit into a modern architecture. And there are more differences between Java EE and distributed and reactive systems. For example, APIs are inherently synchronous, so most Java EE app servers have to scale by adding thread pools as so many things are blocking on I/O (remote JDBC calls, JTA calls, JNDI look ups, even JMS has a lot of synchronous parts). As we know adding thread pools doesn't get you too far in terms of scalability. This talk is going to explore the nine most important differences between classical middleware and distributed, reactive microservices architectures and explains in which cases the distributed approach takes you, where Java EE never would.

A Deeper Look Into Reactive Streams with Akka Streams 1.0 and Slick 3.0

Legacy Typesafe (now Lightbend)

Reactive Streams 1.0.0 is now live, and so are our implementations in Akka Streams 1.0 and Slick 3.0. Reactive Streams is an engineering collaboration between heavy hitters in the area of streaming data on the JVM. With the Reactive Streams Special Interest Group, we set out to standardize a common ground for achieving statically-typed, high-performance, low latency, asynchronous streams of data with built-in non-blocking back pressure—with the goal of creating a vibrant ecosystem of interoperating implementations, and with a vision of one day making it into a future version of Java. Akka (recent winner of “Most Innovative Open Source Tech in 2015”) is a toolkit for building message-driven applications. With Akka Streams 1.0, Akka has incorporated a graphical DSL for composing data streams, an execution model that decouples the stream’s staged computation—it’s “blueprint”—from its execution (allowing for actor-based, single-threaded and fully distributed and clustered execution), type safe stream composition, an implementation of the Reactive Streaming specification that enables back-pressure, and more than 20 predefined stream “processing stages” that provide common streaming transformations that developers can tap into (for splitting streams, transforming streams, merging streams, and more). Slick is a relational database query and access library for Scala that enables loose-coupling, minimal configuration requirements and abstraction of the complexities of connecting with relational databases. With Slick 3.0, Slick now supports the Reactive Streams API for providing asynchronous stream processing with non-blocking back-pressure. Slick 3.0 also allows elegant mapping across multiple data types, static verification and type inference for embedded SQL statements, compile-time error discovery, and JDBC support for interoperability with all existing drivers.

Microservices, Monoliths, SOA and How We Got Here

Lightbend

The Enterprise Architect’s Intro to Microservices - Part 1 of 3 **Find upcoming webinar details here: https://www.lightbend.com/community#filter:webinar** If you’re tired of battling a monolithic enterprise system that’s difficult to scale and maintain––and even harder to understand––then this webinar series is for you. In these three expert sessions, we go over the details of why a microservice-based architecture that consists of small, independent services is far more flexible than the traditional all-in-one systems that continue to dominate today’s enterprise landscape. In Part 1, Enterprise Advocate Kevin Webber will review a bit of history of application development, from the early days of monoliths and SOA to the emergence of Microservice architectures. We will review the drawbacks of heritage architectures and how the principles of Reactive can help you build isolated services that are scalable, resilient to failure, and combine with other services to form a cohesive whole. In the next two webinars, we go deeper into the characteristics of Reactive Microservices, and the considerations how to build complete systems, presented by Lightbend CTO and Akka creator, Jonas Bonér.

What is reactive

Lightbend

Revitalizing Aging Architectures with Microservices

Legacy Typesafe (now Lightbend)

When you need to react quickly to competitive threats, but your existing architecture is anything but nimble, what do you do? In this presentation, you will hear the story of how Walmart Canada revitalized its aging architecture with a microservices model built for speed and performance - that efficiently leveraged its JVM infrastructure - to achieve major e-commerce success in just 12 months: Conversions up 20% Mobile orders up 98% No downtime during Black Friday or Boxing Day This webinar is based off Kevin Webber’s highly successful Gartner session, Lessons Learned: Revitalizing Walmart's Aging Architecture For Web Scale, and will include added content.

Sneaking Scala through the Back Door

Dianne Marsh

Is your organization committed to the power of the Java platform but stuck in the Java language? Do you spend your time wishing you could use Scala at work, but don’t see how you can get it approved? There are good reasons to push for it! Scala is a popular language with Java developers because of its expressiveness and lack of boilerplate code. It allows you to focus on the problem rather than the ceremony required by Java. Yet, businesses are often reluctant to move to Scala, citing concerns about availability of developers and risks of working in a new language. Learn strategies for bringing Scala into your organization, including using it in non-production code, integrating Scala into a Java application, and easing your fellow programmers into functional programming. See how to use Scala for new development while maintaining your investment in existing Java code. Hear stories of how other organizations have done this and succeeded. You’ll leave knowing how you can move to Scala without risking your job or the success of your projects.

Benefits Of The Actor Model For Cloud Computing: A Pragmatic Overview For Jav...

Lightbend

As enterprise development teams increase the time they spend using cloud computing, many are challenged by a move from a scale-up (monolithic) to a scale-out (distributed) architecture. Reactive system development and microservices are two evolving answers that architects are embracing, but making them work well at scale calls for a departure from the traditional approach of object-oriented programming models and defensive programming through try-catch, which is now being replaced by a highly-resilient supervision model and a "let it crash" philosophy. In this webinar for Architects, guest speaker Jeffrey Hammond, Forrester Vice-President and Principal Analyst joins Jonas Bonér, CTO/Co-founder of Lightbend and creator of Akka, the actor-based, message-driven runtime for the JVM, to discuss one emerging programming pattern that’s gaining popularity with teams developing for the cloud––the Actor model. They will discuss some history, why the Actor model is a better fit for large, scale-out systems and microservices delivery, the types of workloads using it today, and how to implement an Actor-based system in your existing Java environment.

Part 2: What you should know about Elasticity, Scalability and Location Transparency in Reactive systems In the second of three webinars with live Q/A, we look into how organizations with Reactive systems are able to adaptively scale in an elastic, infrastructure-efficient way, and the role that location transparency plays in distributed Reactive systems. Reactive Streams contributor and deputy CTO at Typesafe, Inc., Viktor Klang reviews what you should know about: How Reactive systems enable near-linear scalability in order to increase performance proportionally to the allocation of resources, avoiding the constraints of bottlenecks or synchronization points within the system How elasticity builds upon scalability in Reactive systems to automatically adjust the throughput of varying demand when resources are added or removed proportionally and dynamically at runtime. The role of location transparency in distributed computing (in systems running on a single node or on a cluster) and how of decoupling runtime instances from their references can embrace network constraints like partial failure, network splits, dropped messages and more. In the third and final webinar in the series with Jonas Bonér, we go over resiliency, failures vs errors, isolation (and containment), delegation and replication in Reactive systems.

How would ESBs look like, if they were done today.

Markus Eisele

Looking past former hype topics such as enterprise application integration, ESBs, and SOA, the fact is that the need for reliable integration solutions that are manageable and scalable is growing. More devices and datasources, combined with new and upcoming use cases and exciting wearables in a cloudified and heterogeneous infrastructure, require more bits and pieces than just a central ESB with some rules and point-to-point connections. What would that look like? And how can we keep the resultant solutions manageable? Attend this session to find out.

Designing microservices

Masashi Narumoto

URP? Excuse You! The Three Metrics You Have to Know

confluent

(Todd Palino, LinkedIn) Kafka Summit SF 2018 What do you really know about how to monitor a Kafka cluster for problems? Is your most reliable monitoring your users telling you there’s something broken? Are you capturing more metrics than the actual data being produced? Sure, we all know how to monitor disk and network, but when it comes to the state of the brokers, many of us are still unsure of which metrics we should be watching, and what their patterns mean for the state of the cluster. Kafka has hundreds of measurements, from the high-level numbers that are often meaningless to the per-partition metrics that stack up by the thousands as our data grows. We will thoroughly explore three key monitoring concepts in the broker, that will leave you an expert in identifying problems with the least amount of pain: -Under-replicated Partitions: The mother of all metrics -Request Latencies: Why your users complain -Thread pool utilization: How could 80% be a problem? We will also discuss the necessity of availability monitoring and how to use it to get a true picture of what your users see, before they come beating down your door!

Microservices Architecture

Srinivasan Nanduri

THEFT-PROOF JAVA EE - SECURING YOUR JAVA EE APPLICATIONS

Markus Eisele

Security in applications is a never-ending story. Most of the knowledge about how to build secure applications is derived from knowledge and experience. And we've all done the same mistakes every Java EE developer does over and over again. But how to solve the real business requirements behind access and authorization with Java EE? Can I have a 15k rights matrix? Does that perform? How to secure the transport layer? How does session binding works? Can I implement 2-Factor-Authentication? And what about social integrations? This talk outlines the key capabilities of the Java EE platform and introduces the audience to additional frameworks and concepts which do help by implementing all kinds of security requirements in Java EE based applications.

The Road Most Traveled: A Kafka Story | Heikki Nousiainen, Aiven

HostedbyConfluent

When moving to a cloud native architecture Moogsoft knew they needed more scale than Rabbit could provide. Moogsoft moved into Kafka which is known for quick writing and driving heavy event driven workloads on top of niceties such as replayability. Choosing the tool was easy, finding a vendor that ticked all their boxes was not. They needed to ensure scalability, upgradability, builds via existing IAC pipelines, and observability via existing tools. When Moogsoft found Aiven, they were impressed with their offering and ability to scale on demand. During this presentation we will explore how Moogsoft used Aiven for Kafka to manage and scale their data in the cloud.

Integrating Apache Kafka and Elastic Using the Connect Framework

confluent

As a streaming platform, Apache Kafka provides low-latency, high-throughput, fault-tolerant publish and subscribe pipelines and excels at processing streams of real-time events. Kafka provides reliable, millisecond delivery for connecting downstream systems with real-time data. In this talk, we will show how easy it is to leverage Kafka and the Elasticsearch connector to keep your indices populated with the latest data from the rest of your enterprise, as it changes.

20160317 lagom sf scala

shinolajla

Control and monitor_microservices_with_microprofile

Rudy De Busscher

Microservices architecture has many benefits. But it comes at a cost. Running microservices and monitoring what’s going on is tedious. That’s why MicroProfile adopts monitoring as a first-class concept. In this session, learn how MicroProfile runtimes collect metrics and how to seamlessly collect them with tools like Prometheus and Grafana. Learn how MicroProfile makes it easy to connect information about interrelated service calls, how to gather the information and analyze system bottlenecks, how to deploy and scale MicroProfile applications with Kubernetes and how to react to their health status to detect and automatically recover from failures.

Micro service architecture

Ayyappan Paramesh

Designing apps for resiliency

Masashi Narumoto

Gradual migration to MicroProfile

Rudy De Busscher

The goal of MicroProfile is to optimise Java EE for a micro-service architecture. It is based on some of the Java EE specifications and standardise a few technologies from the micro-services space. However, some of the MicroProfile implementations are completely different 'servers', like the KumuluzEE server. So how can you migrate easily from your favorite Java EE server to a MicroProfile implementation? This session shows you an overview of what MicroProfile.IO is and how it relates to Java EE. It then demonstrates with a few examples how you can adjust your Java EE application to incorporate some of the MicroProfile.IO specifications and how you can transform your Java EE application to a MicroProfile.IO one using Thorntail, Payara Micro, and KumuluzEE.

Monitor Micro-service with MicroProfile metrics

Rudy De Busscher

Transactions in micro-services (fall 2019)

Rudy De Busscher

How can you make different pieces of your unit of work consistent in the distributed setup of your micro-service application? You associate the term transaction probably with a database, but the data source can be anything including a database in the micro-service world. The MicroProfile Long Running Actions specification is based on sagas and the OASIS LRA transaction model specification. It defines the framework to guarantee the eventual consistency requirement using compensating actions for example. This session will explain you the challenges and concepts of the MP LRA framework.

The Reactive Principles: Eight Tenets For Building Cloud Native Applications

Lightbend

Enterprise Development Trends 2016 - Cloud, Container and Microservices Insig...

Lightbend

In the past, infrastructure was left to operations teams. Today, it’s JVM developers themselves being brought into the DevOps tent based on the new characteristics of the modern enterprise application, as well as major innovations in the infrastructure running it. Lightbend surveyed 2,151 global respondents working on the JVM to discover: Correlations between development trends and IT infrastructure trends How organizations at the forefront of digital transformation are modernizing their applications Real production usage break-downs of today’s most buzzed about emerging technologies The survey gathered responses from a diverse range of companies, with 20 percent of respondents hailing from companies with more than 5,000 employees (large organizations), 28 percent from companies with 200-5,000 employees (medium sized organizations) and 52 percent from companies with fewer than 200 employees.

Distributed Systems Done Right: Why Java Enterprises Are Embracing The Actor ...

Lightbend

Most likely, your job is heavily focused on helping your organization modernize for the digital era. As the days of purely Object-Oriented Programming and related frameworks come to a close, enterprises migrating to distributed, cloud infrastructures are embracing a different approach: the Actor Model. When it comes to distributed computing, the Actor Model is the great-grandparent of it all. Created by Carl Hewitt in 1973, Forrester Research notes, “the Actor model is seeing renewed interest as cloud concurrency challenges grow.” Yet even if you understand the Actor Model and used some of the toolkits for it (e.g. Akka and Erlang), how do you easily explain the concept to your team, colleagues and managers? Where do you start? In this webinar, Hugh McKee, Global Solutions Architect at Lightbend, shows you how Actors behave and interact as humans do when it comes to communicating, and how these similar behavioral patterns provide basic intuition when designing Reactive systems. Actors allow your teams to focus on an application’s business logic rather than on low-level protocols, accelerating time-to-market while keeping your infrastructure costs low. Our goal is twofold: provide you with a comprehensive review of the Actor Model, and give you the resources you need to help others learn why enterprises like Walmart, Intel, Samsung, IBM, Norwegian Cruise Lines and HSBC are committed production users of Akka, the JVM-based toolkit built on the Actor Model. In this webinar, you’ll learn: *Why actor-based systems are one of the foundational technologies for creating microservices architecture (MSA) *How Actors delegate work by creating other Actors in a supervisor-to-worker relationship *How Actors manage requests and scale horizontally in large systems *The difference between traditional systems and actor-based systems *How an Actor system forms clusters when the flow of work exceeds a system’s capacity to process it *Why failure detection and failure recovery is an architectural feature of Actor systems *An example of using Actors to build an Internet of Things (IoT) application Visit Lightbend.com/blog for more goodness.

What's hot

The Future of Services: Building Asynchronous, Resilient and Elastic Systems

Lightbend

What is Reactive programming?

Kevin Webber

Digital Transformation with Kubernetes, Containers, and Microservices

Lightbend

Microservices and Integration: what's next with Istio service mesh

Christian Posta

Reactive Revealed Part 2: Scalability, Elasticity and Location Transparency i...

Legacy Typesafe (now Lightbend)

How would ESBs look like, if they were done today.

Markus Eisele

Designing microservices

Masashi Narumoto

URP? Excuse You! The Three Metrics You Have to Know

confluent

Microservices Architecture

Srinivasan Nanduri

THEFT-PROOF JAVA EE - SECURING YOUR JAVA EE APPLICATIONS

Markus Eisele

The Road Most Traveled: A Kafka Story | Heikki Nousiainen, Aiven

HostedbyConfluent

Integrating Apache Kafka and Elastic Using the Connect Framework

confluent

20160317 lagom sf scala

shinolajla

Control and monitor_microservices_with_microprofile

Rudy De Busscher

Micro service architecture

Ayyappan Paramesh

Designing apps for resiliency

Masashi Narumoto

Gradual migration to MicroProfile

Rudy De Busscher

Monitor Micro-service with MicroProfile metrics

Rudy De Busscher

Transactions in micro-services (fall 2019)

Rudy De Busscher

The Reactive Principles: Eight Tenets For Building Cloud Native Applications

Lightbend

What's hot (20)

The Future of Services: Building Asynchronous, Resilient and Elastic Systems

What is Reactive programming?

Digital Transformation with Kubernetes, Containers, and Microservices

Microservices and Integration: what's next with Istio service mesh

Reactive Revealed Part 2: Scalability, Elasticity and Location Transparency i...

How would ESBs look like, if they were done today.

Designing microservices

URP? Excuse You! The Three Metrics You Have to Know

Microservices Architecture

THEFT-PROOF JAVA EE - SECURING YOUR JAVA EE APPLICATIONS

The Road Most Traveled: A Kafka Story | Heikki Nousiainen, Aiven

Integrating Apache Kafka and Elastic Using the Connect Framework

20160317 lagom sf scala

Control and monitor_microservices_with_microprofile

Micro service architecture

Designing apps for resiliency

Gradual migration to MicroProfile

Monitor Micro-service with MicroProfile metrics

Transactions in micro-services (fall 2019)

The Reactive Principles: Eight Tenets For Building Cloud Native Applications

Viewers also liked

Enterprise Development Trends 2016 - Cloud, Container and Microservices Insig...

Lightbend

Distributed Systems Done Right: Why Java Enterprises Are Embracing The Actor ...

Lightbend

Understanding Akka Streams, Back Pressure, and Asynchronous Architectures

Lightbend

The term 'streams' has been getting pretty overloaded recently–it's hard to know where to best use different technologies with streams in the name. In this talk by noted hAkker Konrad Malawski, we'll disambiguate what streams are and what they aren't, taking a deeper look into Akka Streams (the implementation) and Reactive Streams (the standard). You'll be introduced to a number of real life scenarios where applying back-pressure helps to keep your systems fast and healthy at the same time. While the focus is mainly on the Akka Streams implementation, the general principles apply to any kind of asynchronous, message-driven architectures.

DLJCJUG 2015: The Seven Deadly Sins of Microservices

Daniel Bryant

All is not completely rosy in microservice-land. It is often a sign of an architectural approach’s maturity that in addition to the emergence of well-established principles and practices, that anti-patterns also begin to be identified and classified. In this talk we introduce seven deadly sins that if left unchecked could easily ruin your next microservices project... This talk will take a tour of some of the nastiest anti-patterns in microservices, giving you the tools to not only avoid but also slay these demons before they tie up your project in their own special brand of hell. Topics covered include: Pride - selfishly ignoring the new requirements for testing; Envy - introducing inappropriate intimacy within services by creating a shared domain model; Wrath - failing to deal with the inevitable bad things that occur within a distributed system; Sloth - composing services in a lazy fashion, which ultimately leads to the creation of a “Distributed Monolith”; and Lust - embracing the latest and greatest technology without evaluating the operational impact incurred by these choices.

Akka 2.4 plus new commercial features in Typesafe Reactive Platform

Legacy Typesafe (now Lightbend)

Technologies Referenced: Akka, Typesafe Reactive Platform Technical Level: Introductory Audience: Senior Developers, Architects Presenter: Konrad Malawski, Akka Software Engineer, Typesafe, Inc. Akka is a runtime framework for building resilient, distributed applications in Java or Scala. In this webinar, Konrad Malawski discusses the roadmap and features of the upcoming Akka 2.4.0 and reveals three upcoming enhancements that enterprises will receive in the latest certified, tested build of Typesafe Reactive Platform. Akka Split Brain Resolver (SBR) Akka SBR provides advanced recovery scenarios in Akka Clusters, improving on the safety of Akka’s automatic resolution to avoid cascading partitioning. Akka Support for Docker and NAT Run Akka Clusters in Docker containers or NAT with complete hostname and port visibility on Java 6+ and Akka 2.3.11+ Akka Long-Term Support Receive Akka 2.4 support for Java 6, Java 7, and Scala 2.10

Microservices Practitioner Summit Jan '15 - Don't Build a Distributed Monolit...

Ambassador Labs

Ben Christensen of Facebook, Netflix, and author of Hystrix. In pursuit of ease and obedience to the DRY ("don't repeat yourself") axiom, it is common to build a distributed monolith instead of the intended decoupled microservice architecture. This talk will explore the common pitfalls, the pain they cause, and approaches to connecting microservice permitting the promised separation of concerns that allows varied architectures, platforms, languages, timelines, and incremental rewrites of a microservice system. Full video here: http://www.microservices.com/ben-christensen-do-not-build-a-distributed-monolith

CARTO ENGINE

Jorge Sanz

API-driven Legacy Migration: Results from Project WinterfellKeith McFarlane

REST и HATEOAS

Artem Bey

API Services: Building Apps That Stand Out

Apigee | Google Cloud

Modern apps require data services that your back-end infrastructure may lack.Discover how to build successful apps using the Apigee API Services toolkit. Learn how your developers can take advantage of Apigee's mBaaS solution to build and scale their apps without having to stand up an internal database. Deep dive into the API-enabled backend system that enables developers to build features like user management, push notifications, social graph, geo-location and more.

Modernizing the Legacy - How Dish is Adapting its SOA Services for a Cloud Fi...

VMware Tanzu

SpringOne Platform 2016 Speakers: Rob Bennett; Director, Development, Dish Networks; Chandra Nemalipuri; Principal Software Engineer, Dish Networks; Lax Rastogi; Senior Manager, Dish Networks Like many companies, Dish has a large number of SOA services that have been built using previous generations of technology. In this session we will discuss the challenges faced in converting legacy services to cloud native applications and the different approaches we considered for resolving the conflicts. We will then dive deeper into the approach that we chose to modernize our services and put us on a track towards a microservices based architecture running on Cloud Foundry.

Securing RESTful services with Spring HATEOAS & Hdiv

Hdiv Security

Hypermedia api (HATEOAS)MitinPavel

HCLT Whitepaper: Legacy Modernization

HCL Technologies

http://www.hcltech.com/ - More on HCL Technologies According to industry estimates most of the business critical applications for not only midsize companies, but also many Fortune 500 corporations run on legacy systems, due to the system’s excellent performance and stability. CIO’s and IT managers handling these applications constantly face challenges such as: High cost of supporting and maintaining the expensive legacy applications. Inefficient, slow and less productive system compared to competition. Unmitigated risk associated with lack of skill availability in the resource market. Risk associated with running business critical application on unsupported platform. Higher time to market due to large, monolithic, complex and less productive systems. Integration with newer systems due to incompatibility with new and different technologies.

BPM for SOA+ESB+API and cloud

Alexander SAMARIN

How to become a Product Samurai - Chris Lukassen

Avisi B.V.

Apiworld

Owen Rubel

The API pattern was created in the 1970's when 'distributed architectures' didn't even exist and was established mainly for 'centralized architectures' as it bound the communication data/logic to the business logic. In a modern world, we have moved to distributed architectures where we now have to share the I/O... but that communication logic still remains bound in the application due to an old API pattern. This makes it so that the IO data and functionality related to a request/response cannot be shared with our edge services without duplication/entanglement. This in turn means the data/functionality in our services then cannot be synchronized. This leads to dropped threads, poor security, bad data, bad user experience, broken application, etc. This can ALL be fixed and improved and even lead to better speed, scalability and automation through a new API Pattern.

Legacy to industry leader: a modernization case study

OSSCube

Twilio Signal 2016 API Architecture

Twilio Inc

Going Reactive in Java with Typesafe Reactive Platform

Legacy Typesafe (now Lightbend)

FOR THE FULL VIDEO, RECORDING & PRESENTATION: https://typesafe.com/blog/going-reactive-in-java-with-typesafe-reactive-platform -- In this presentation by Jamie Allen, we do a deep dive into the Typesafe Reactive Platform from the Java developer’s perspective, to learn how Typesafe supports the entire Reactive application development lifecycle. Reactive application development is becoming mainstream and considered a mission-critical need for future growth. This new wave of business applications are message-driven, elastic, resilient and responsive by nature, designed to scale elastically and maintain responsiveness during even large failures. With the Typesafe Reactive Platform (RP), including Play Framework and Akka, Java developers can start to use tools designed for building distributed systems that deliver highly-responsive user experiences. Regardless of whether you code in Java or Scala, Typesafe RP provides a resilient and message-driven application stack that scales effortlessly on multicore and cloud computing architectures.

Viewers also liked (20)

Enterprise Development Trends 2016 - Cloud, Container and Microservices Insig...

Distributed Systems Done Right: Why Java Enterprises Are Embracing The Actor ...

Understanding Akka Streams, Back Pressure, and Asynchronous Architectures

DLJCJUG 2015: The Seven Deadly Sins of Microservices

Akka 2.4 plus new commercial features in Typesafe Reactive Platform

Microservices Practitioner Summit Jan '15 - Don't Build a Distributed Monolit...

CARTO ENGINE

API-driven Legacy Migration: Results from Project Winterfell

REST и HATEOAS

API Services: Building Apps That Stand Out

Modernizing the Legacy - How Dish is Adapting its SOA Services for a Cloud Fi...

Securing RESTful services with Spring HATEOAS & Hdiv

Hypermedia api (HATEOAS)

HCLT Whitepaper: Legacy Modernization

BPM for SOA+ESB+API and cloud

How to become a Product Samurai - Chris Lukassen

Apiworld

Legacy to industry leader: a modernization case study

Twilio Signal 2016 API Architecture

Going Reactive in Java with Typesafe Reactive Platform

Similar to The 6 Rules for Modernizing Your Legacy Java Monolith with Microservices

Microservices: Architecture for the Real-time Organization

Kevin Webber

The real-time organization is responsive to change. Real-time organizations architect their systems to evolve naturally as they adapt to the competitive landscape around them. At the core of real-time organizations are microservices. The microservice architecture (MSA) empowers independent teams within large organizations to move at the pace of startups, freeing them from the constraints of “design by committee” and other architectural anti-patterns that ground productivity within the enterprise to a halt. We explore all of the relevant patterns of microservices architecture including domain-driven design (DDD), circuit breaker, data pump, saga pattern, distributed transaction, async messaging, etc.

Revitalizing Walmart's Aging Architecture for Web Scale

Kevin Webber

Exploring microservices in a Microsoft landscape

Alex Thissen

Presentation for Dutch Microsoft TechDays 2015 with Marcel de Vries: During this session we will take a look at how to realize a Microservices architecture (MSA) using the latest Microsoft technologies available. We will discuss some fundamental theories behind MSA and show you how this can actually be realized with Microsoft technologies such as Azure Service Fabric. This session is a real must-see for any developer that wants to stay ahead of the curve in modern architectures.

Microservices: Where do they fit within a rapidly evolving integration archit...

Kim Clark

Do microservices force us to look differently at the way we lay down and evolve our integration architecture, or are they purely about how we build applications? Are microservices a new concept, or an evolution of the many ideas that came before them? What is the relationship between microservices and other key initiatives such as APIs, SOA, and Agile. In this session, we will unpick what microservices really are, and indeed what they are not. We will consider whether there is something unique about this particular point time in technology that has enables microservice concepts to take hold. Finally, we will look at if, when, where and how an enterprise can take on the benefits of microservices, and what products and technologies are applicable for that journey.

Microservices Corporate Style

Narendranath Reddy

Redis and Kafka - Advanced Microservices Design Patterns Simplified

Allen Terleto

The adoption and popularity of the microservices architecture continues to grow across a spectrum of enterprises in every industry. Although a consensus on an implementation standard has yet to be reached, advanced design patterns and lessons learned about the complexities and pitfalls of deploying microservices at scale have been established by thought leaders and the development community. With Redis and Kafka becoming de facto standards across most microservices architectures, we will discuss how their combination can be used to simplify the implementation of event-driven design patterns that will provide real-time performance, scalability, resiliency, traceability to ensure compliance, observability, reduced technology sprawl, and scale to thousands of services. In this discussion, we will decompose a real-time event-driven payment-processing microservices workflow to explore capturing telemetry data, event sourcing, CQRS, orchestrated SAGA workflows, inter-service communication, state machines, and more.

Redis and Kafka - Simplifying Advanced Design Patterns within Microservices A...

HostedbyConfluent

Micro services Architecture

Jenis Dharmadurai

Amazon EKS 그리고 Service Mesh (김세호 솔루션즈 아키텍트, AWS) :: Gaming on AWS 2018

Amazon Web Services Korea

Amazon EKS 그리고 Service Mesh Kubernetes는 컨테이너 서비스를 도입하는 기업들에게 가장 있기있는 Orchestration 플랫폼입니다. 이 세션에서는 아마존에서 6월 정식 출시한 managed Kubenetes서비스인 EKS를 소개해드리며, 오픈소스 버전과의 차이점 및 장점 등에 대해 설명하고, 진보한 마이크로 서비스인 Service Mesh를 구현하는 Linkerd 소개 및 데모를 진행하고자 합니다.

Internet Scale Architecture

RightScale

Cloud computing revolutionized application design, and changed the way people think about infrastructure. The rise of cloud computing coincided with a new generation of applications and services that required scale. New architecture and design had to take into account low latency network connectivity, geographic distribution, large real-time data stores, the ability to meet demand (while not knowing exactly how much demand to handle), and so much more. We refer to this as Internet Scale. Yet most discussion of scale and cloud revolves around compute as virtualized instances, which have defined configurations and constrained options. Delivering on the promise of Internet Scale involves substantial upfront design, and a comprehensive understanding of the entire architecture - from the underlying hardware, to the operating system, the application stack, services, and deployment. And, it involves choice - choices you should make based on your requirements. Join us for a discussion on the many facets of Internet Scale, and how it can apply to your applications and services.

Net core microservice development made easy with azure dev spaces

Alon Fliess

Accelerate DevOps/Microservices and Kubernetes

Rick Hightower

Monoliths to Microservices with Jave EE and Spring Boot

Tiera Fann, MBA

Database@Home : Data Driven Apps - Data-driven Microservices Architecture wit...

Tammy Bednar

This talk provides an architecture overview of data-centric microservices illustrated with an example application. The following Microservices concepts are illustrated - domain driven design, event-driven services, Saga transactions, Application tracing and Health monitoring with different microservices using a variety of data types supported in the database - business data, documents, spatial, graph, and events. A running example of a mobile food delivery application (called GrubDash) is used, with a hands-on-lab that is available for attendees to work through on the Oracle Cloud after these sessions. The rest of the talks will build upon this Microservices architecture framework.

Introduction To Microservices

Lalit Kale

This presentation is conducted on 14th Sept in Limerick DotNet User Group. (https://www.meetup.com/preview/Limerick-DotNet/events/xskpdnywmbsb) SlideShare Url: https://www.slideshare.net/lalitkale/introduction-to-microservices-80583928 In this presentation, new architectural style - Microservices and it's emergence is discussed. We will also briefly touch base on what are not microservices, Conway's law and organization design, Principles of microservices and service discovery mechanism and why it is necessary for microservices implementation. About Speaker: Lalit is a senior developer, software architect and consultant with more than 12 yrsof .NET experience. He loves to work with C# .NET and Azure platform services like App Services, Virtual Machines, Cortana, and Container Services. He is also the author of 'Building Microservices with .NET Core' (https://www.packtpub.com/web-development/building-microservices-net-core) book. To know more and connect with Lalit, you can visit his LinkedIn profile below. https://www.linkedin.com/in/lalitkale/ This presentation will be useful for software architects/Managers, senior developers. Do share your feedback in comments.

Microservices Docker Kubernetes Istio Kanban DevOps SRE

Araf Karsh Hamid

Introduction to Microservices Architecture, Docker, Kubernetes, Istio, Testing Strategies for Microservices based Apps. Security Best Practices. Kanban, DevOps, and SRE. Infrastructure Design Patterns - API Gateway - Service Discovery - Load Balancer - Circuit Breaker - Let-it-Crash Pattern Software Design Patterns - Hexagonal Architecture - Domain Driven Design - Event Sourcing and CQRS - Functional Reactive Programming

Monolithic to Microservices Architecture

Vin Dahake

AWS Serverless Community Day Keynote and Vendia Launch 6-26-2020

Tim Wagner

Stay productive while slicing up the monolith

Markus Eisele

Microservice & Service Mesh Workshop

Claudio Acquaviva

Similar to The 6 Rules for Modernizing Your Legacy Java Monolith with Microservices (20)

Microservices: Architecture for the Real-time Organization

Revitalizing Walmart's Aging Architecture for Web Scale

Exploring microservices in a Microsoft landscape

Microservices: Where do they fit within a rapidly evolving integration archit...

Microservices Corporate Style

Redis and Kafka - Advanced Microservices Design Patterns Simplified

Redis and Kafka - Simplifying Advanced Design Patterns within Microservices A...

Micro services Architecture

Amazon EKS 그리고 Service Mesh (김세호 솔루션즈 아키텍트, AWS) :: Gaming on AWS 2018

Internet Scale Architecture

Net core microservice development made easy with azure dev spaces

Accelerate DevOps/Microservices and Kubernetes

Monoliths to Microservices with Jave EE and Spring Boot

Database@Home : Data Driven Apps - Data-driven Microservices Architecture wit...

Introduction To Microservices

Microservices Docker Kubernetes Istio Kanban DevOps SRE

Monolithic to Microservices Architecture

AWS Serverless Community Day Keynote and Vendia Launch 6-26-2020

Stay productive while slicing up the monolith

Microservice & Service Mesh Workshop

More from Lightbend

IoT 'Megaservices' - High Throughput Microservices with Akka

Lightbend

********** Watch this presentation on-demand! https://info.lightbend.com/iot-megaservices-high-throughput-microservices-with-akka-register.html ********** In this interactive presentation by Hugh McKee, Developer Advocate at Lightbend, we’ll share our experiences helping our clients create a system architecture that can support high throughput microservices (aka "Megaservices"). We’ll do that using IoT demo applications designed to push cloud service providers like Amazon and Google to their limits. Using sample code that you can later run on your own machine, we’ll look at: * Modeling real-life digital twins for hundreds of thousands of IoT devices in the field, looking into how these megaservices are implemented in Akka. * Visualizing Akka Actors–which represent IoT digital twins–in a “crop circle” formation that represents a complete distributed Reactive application, and watching at messages are processed across Akka Cluster nodes using cluster sharding. * Some code behind the whole set up, which is built using OSS like Akka, Java, JavaScript, and Kubernetes. Follow us on social: TW: https://twitter.com/lightbend LI: https://www.linkedin.com/company/lightbend-inc-/ FB: https://www.facebook.com/lightbendOfficial/ For more about Lightbend: Blog: https://www.lightbend.com/blog  Newsletter: https://www.lightbend.com/newsletter 

How Akka Cluster Works: Actors Living in a Cluster

Lightbend

Putting the 'I' in IoT - Building Digital Twins with Akka Microservices

Lightbend

Akka at Enterprise Scale: Performance Tuning Distributed Applications

Lightbend

Organizations like Starbucks, HPE, and PayPal (see our customers) have selected the Akka toolkit for their enterprise scale distributed applications; and when it comes to squeezing out the best possible performance, the secret is using two particular modules in tandem: Akka Cluster and Akka Streams. In this webinar by Nolan Grace, Senior Solution Architect at Lightbend, we look at these two Akka modules and discuss the features that will push your application architecture to the next tier of performance. For the full blog post, including the video, visit: https://www.lightbend.com/blog/akka-at-enterprise-scale-performance-tuning-distributed-applications

Detecting Real-Time Financial Fraud with Cloudflow on Kubernetes

Lightbend

Deploying a robust streaming data pipeline can be a daunting task when your company’s financial information is at risk. For starters, how do you ensure proper provisioning of resources? How do you preserve end-to-end application and data consistency? How do you make all of this work in the cloud with Kubernetes and avoid YAML hell? Answer: Cloudflow, a new open-source toolkit for simplifying the development, deployment, and operation of streaming data pipelines.

Cloudstate - Towards Stateful Serverless

Lightbend

Digital Transformation from Monoliths to Microservices to Serverless and Beyond

Lightbend

Join this highly-visual presentation by Hugh McKee, Developer Advocate at Lightbend, to learn more about the ramifications and opportunities along the evolution from monolithic systems, to microservices architectures, to serverless (FaaS). See the video presentation on the Lightbend blog at: https://www.lightbend.com/blog/digital-transformation-from-monoliths-to-microservices-to-serverless-and-beyond

Akka Anti-Patterns, Goodbye: Six Features of Akka 2.6

Lightbend

Lessons From HPE: From Batch To Streaming For 20 Billion Sensors With Lightbe...

Lightbend

How to build streaming data pipelines with Akka Streams, Flink, and Spark usi...

Lightbend

Microservices, Kubernetes, and Application Modernization Done Right

Lightbend

In this talk by David Ogren, Enterprise Architect at Lightbend, we draw from experiences helping our clients successfully create, migrate to, and manage cloud-native system architectures. We look at some of the common pitfalls and anti-patterns of modernization efforts, and some of the best practices for taking an incremental approach to transforming legacy systems. See the full post with video on the Lightbend blog: https://www.lightbend.com/blog/microservices-kubernetes-application-modernization

Full Stack Reactive In Practice

Lightbend

Akka and Kubernetes: A Symbiotic Love Story

Lightbend

Scala 3 Is Coming: Martin Odersky Shares What To Know

Lightbend

Migrating From Java EE To Cloud-Native Reactive Systems

Lightbend

A lot of businesses that never before considered themselves as “technology companies” are now faced with digital modernization imperatives that force them to rethink their application and infrastructure architecture. On the path to becoming a digital, on-demand provider, development speed is the ultimate competitive advantage. This presents challenges to many organizations that have huge investments in legacy Java EE infrastructure, where technical debt and monolithic system architectures require modernization in order to confront various business risks. Usually, changes need to be made within existing frameworks to keep pace with new web-scale organizations. If your legacy monolith is no longer serving the expanding needs of your business, then join Markus Eisele, Director of Developer Advocacy at Lightbend, to learn what you can do to migrate from Java EE to cloud-native, Reactive systems—as defined by the Reactive Manifesto.

Running Kafka On Kubernetes With Strimzi For Real-Time Streaming Applications

Lightbend

In this talk by Sean Glover, Principal Engineer at Lightbend, we will review how the Strimzi Kafka Operator, a supported technology in Lightbend Platform, makes many operational tasks in Kafka easy, such as the initial deployment and updates of a Kafka and ZooKeeper cluster. See the blog post containing the YouTube video here: https://www.lightbend.com/blog/running-kafka-on-kubernetes-with-strimzi-for-real-time-streaming-applications

Designing Events-First Microservices For A Cloud Native World

Lightbend

Scala Security: Eliminate 200+ Code-Level Threats With Fortify SCA For Scala

Lightbend

How To Build, Integrate, and Deploy Real-Time Streaming Pipelines On Kubernetes

Lightbend

A Glimpse At The Future Of Apache Spark 3.0 With Deep Learning And Kubernetes

Lightbend

More from Lightbend (20)

IoT 'Megaservices' - High Throughput Microservices with Akka

How Akka Cluster Works: Actors Living in a Cluster

Putting the 'I' in IoT - Building Digital Twins with Akka Microservices

Akka at Enterprise Scale: Performance Tuning Distributed Applications

Detecting Real-Time Financial Fraud with Cloudflow on Kubernetes

Cloudstate - Towards Stateful Serverless

Digital Transformation from Monoliths to Microservices to Serverless and Beyond

Akka Anti-Patterns, Goodbye: Six Features of Akka 2.6

Lessons From HPE: From Batch To Streaming For 20 Billion Sensors With Lightbe...

How to build streaming data pipelines with Akka Streams, Flink, and Spark usi...

Microservices, Kubernetes, and Application Modernization Done Right

Full Stack Reactive In Practice

Akka and Kubernetes: A Symbiotic Love Story

Scala 3 Is Coming: Martin Odersky Shares What To Know

Migrating From Java EE To Cloud-Native Reactive Systems

Running Kafka On Kubernetes With Strimzi For Real-Time Streaming Applications

Designing Events-First Microservices For A Cloud Native World

Scala Security: Eliminate 200+ Code-Level Threats With Fortify SCA For Scala

How To Build, Integrate, and Deploy Real-Time Streaming Pipelines On Kubernetes

A Glimpse At The Future Of Apache Spark 3.0 With Deep Learning And Kubernetes

Recently uploaded

Accelerate Enterprise Software Engineering with Platformless

WSO2

Key takeaways: Challenges of building platforms and the benefits of platformless. Key principles of platformless, including API-first, cloud-native middleware, platform engineering, and developer experience. How Choreo enables the platformless experience. How key concepts like application architecture, domain-driven design, zero trust, and cell-based architecture are inherently a part of Choreo. Demo of an end-to-end app built and deployed on Choreo.

First Steps with Globus Compute Multi-User Endpoints

Globus

In this presentation we will share our experiences around getting started with the Globus Compute multi-user endpoint. Working with the Pharmacology group at the University of Auckland, we have previously written an application using Globus Compute that can offload computationally expensive steps in the researcher's workflows, which they wish to manage from their familiar Windows environments, onto the NeSI (New Zealand eScience Infrastructure) cluster. Some of the challenges we have encountered were that each researcher had to set up and manage their own single-user globus compute endpoint and that the workloads had varying resource requirements (CPUs, memory and wall time) between different runs. We hope that the multi-user endpoint will help to address these challenges and share an update on our progress here.

Exploring Innovations in Data Repository Solutions - Insights from the U.S. G...

Globus

The U.S. Geological Survey (USGS) has made substantial investments in meeting evolving scientific, technical, and policy driven demands on storing, managing, and delivering data. As these demands continue to grow in complexity and scale, the USGS must continue to explore innovative solutions to improve its management, curation, sharing, delivering, and preservation approaches for large-scale research data. Supporting these needs, the USGS has partnered with the University of Chicago-Globus to research and develop advanced repository components and workflows leveraging its current investment in Globus. The primary outcome of this partnership includes the development of a prototype enterprise repository, driven by USGS Data Release requirements, through exploration and implementation of the entire suite of the Globus platform offerings, including Globus Flow, Globus Auth, Globus Transfer, and Globus Search. This presentation will provide insights into this research partnership, introduce the unique requirements and challenges being addressed and provide relevant project progress.

Understanding Globus Data Transfers with NetSage

Globus

NetSage is an open privacy-aware network measurement, analysis, and visualization service designed to help end-users visualize and reason about large data transfers. NetSage traditionally has used a combination of passive measurements, including SNMP and flow data, as well as active measurements, mainly perfSONAR, to provide longitudinal network performance data visualization. It has been deployed by dozens of networks world wide, and is supported domestically by the Engagement and Performance Operations Center (EPOC), NSF #2328479. We have recently expanded the NetSage data sources to include logs for Globus data transfers, following the same privacy-preserving approach as for Flow data. Using the logs for the Texas Advanced Computing Center (TACC) as an example, this talk will walk through several different example use cases that NetSage can answer, including: Who is using Globus to share data with my institution, and what kind of performance are they able to achieve? How many transfers has Globus supported for us? Which sites are we sharing the most data with, and how is that changing over time? How is my site using Globus to move data internally, and what kind of performance do we see for those transfers? What percentage of data transfers at my institution used Globus, and how did the overall data transfer performance compare to the Globus users?

Providing Globus Services to Users of JASMIN for Environmental Data Analysis

Globus

JASMIN is the UK’s high-performance data analysis platform for environmental science, operated by STFC on behalf of the UK Natural Environment Research Council (NERC). In addition to its role in hosting the CEDA Archive (NERC’s long-term repository for climate, atmospheric science & Earth observation data in the UK), JASMIN provides a collaborative platform to a community of around 2,000 scientists in the UK and beyond, providing nearly 400 environmental science projects with working space, compute resources and tools to facilitate their work. High-performance data transfer into and out of JASMIN has always been a key feature, with many scientists bringing model outputs from supercomputers elsewhere in the UK, to analyse against observational or other model data in the CEDA Archive. A growing number of JASMIN users are now realising the benefits of using the Globus service to provide reliable and efficient data movement and other tasks in this and other contexts. Further use cases involve long-distance (intercontinental) transfers to and from JASMIN, and collecting results from a mobile atmospheric radar system, pushing data to JASMIN via a lightweight Globus deployment. We provide details of how Globus fits into our current infrastructure, our experience of the recent migration to GCSv5.4, and of our interest in developing use of the wider ecosystem of Globus services for the benefit of our user community.

OpenFOAM solver for Helmholtz equation, helmholtzFoam / helmholtzBubbleFoam

takuyayamamoto1800

Strategies for Successful Data Migration Tools.pptx

varshanayak241

Data migration is a complex but essential task for organizations aiming to modernize their IT infrastructure and leverage new technologies. By understanding common challenges and implementing these strategies, businesses can achieve a successful migration with minimal disruption. Data Migration Tool like Ask On Data play a pivotal role in this journey, offering features that streamline the process, ensure data integrity, and maintain security. With the right approach and tools, organizations can turn the challenge of data migration into an opportunity for growth and innovation.

Globus Compute wth IRI Workflows - GlobusWorld 2024

Globus

As part of the DOE Integrated Research Infrastructure (IRI) program, NERSC at Lawrence Berkeley National Lab and ALCF at Argonne National Lab are working closely with General Atomics on accelerating the computing requirements of the DIII-D experiment. As part of the work the team is investigating ways to speedup the time to solution for many different parts of the DIII-D workflow including how they run jobs on HPC systems. One of these routes is looking at Globus Compute as a way to replace the current method for managing tasks and we describe a brief proof of concept showing how Globus Compute could help to schedule jobs and be a tool to connect compute at different facilities.

De mooiste recreatieve routes ontdekken met RouteYou en FME

Jelle | Nordend

Climate Science Flows: Enabling Petabyte-Scale Climate Analysis with the Eart...

Globus

The Earth System Grid Federation (ESGF) is a global network of data servers that archives and distributes the planet’s largest collection of Earth system model output for thousands of climate and environmental scientists worldwide. Many of these petabyte-scale data archives are located in proximity to large high-performance computing (HPC) or cloud computing resources, but the primary workflow for data users consists of transferring data, and applying computations on a different system. As a part of the ESGF 2.0 US project (funded by the United States Department of Energy Office of Science), we developed pre-defined data workflows, which can be run on-demand, capable of applying many data reduction and data analysis to the large ESGF data archives, transferring only the resultant analysis (ex. visualizations, smaller data files). In this talk, we will showcase a few of these workflows, highlighting how Globus Flows can be used for petabyte-scale climate analysis.

BoxLang: Review our Visionary Licenses of 2024

Ortus Solutions, Corp

Innovating Inference - Remote Triggering of Large Language Models on HPC Clus...

Globus

Large Language Models (LLMs) are currently the center of attention in the tech world, particularly for their potential to advance research. In this presentation, we'll explore a straightforward and effective method for quickly initiating inference runs on supercomputers using the vLLM tool with Globus Compute, specifically on the Polaris system at ALCF. We'll begin by briefly discussing the popularity and applications of LLMs in various fields. Following this, we will introduce the vLLM tool, and explain how it integrates with Globus Compute to efficiently manage LLM operations on Polaris. Attendees will learn the practical aspects of setting up and remotely triggering LLMs from local machines, focusing on ease of use and efficiency. This talk is ideal for researchers and practitioners looking to leverage the power of LLMs in their work, offering a clear guide to harnessing supercomputing resources for quick and effective LLM inference.

Lecture 1 Introduction to games development

abdulrafaychaudhry

Visitor Management System in India- Vizman.app

NaapbooksPrivateLimi

Your Digital Assistant. Making complex approach simple. Straightforward process saves time. No more waiting to connect with people that matter to you. Safety first is not a cliché - Securely protect information in cloud storage to prevent any third party from accessing data. Would you rather make your visitors feel burdened by making them wait? Or choose VizMan for a stress-free experience? VizMan is an automated visitor management system that works for any industries not limited to factories, societies, government institutes, and warehouses. A new age contactless way of logging information of visitors, employees, packages, and vehicles. VizMan is a digital logbook so it deters unnecessary use of paper or space since there is no requirement of bundles of registers that is left to collect dust in a corner of a room. Visitor’s essential details, helps in scheduling meetings for visitors and employees, and assists in supervising the attendance of the employees. With VizMan, visitors don’t need to wait for hours in long queues. VizMan handles visitors with the value they deserve because we know time is important to you. Feasible Features One Subscription, Four Modules – Admin, Employee, Receptionist, and Gatekeeper ensures confidentiality and prevents data from being manipulated User Friendly – can be easily used on Android, iOS, and Web Interface Multiple Accessibility – Log in through any device from any place at any time One app for all industries – a Visitor Management System that works for any organisation. Stress-free Sign-up Visitor is registered and checked-in by the Receptionist Host gets a notification, where they opt to Approve the meeting Host notifies the Receptionist of the end of the meeting Visitor is checked-out by the Receptionist Host enters notes and remarks of the meeting Customizable Components Scheduling Meetings – Host can invite visitors for meetings and also approve, reject and reschedule meetings Single/Bulk invites – Invitations can be sent individually to a visitor or collectively to many visitors VIP Visitors – Additional security of data for VIP visitors to avoid misuse of information Courier Management – Keeps a check on deliveries like commodities being delivered in and out of establishments Alerts & Notifications – Get notified on SMS, email, and application Parking Management – Manage availability of parking space Individual log-in – Every user has their own log-in id Visitor/Meeting Analytics – Evaluate notes and remarks of the meeting stored in the system Visitor Management System is a secure and user friendly database manager that records, filters, tracks the visitors to your organization. "Secure Your Premises with VizMan (VMS) – Get It Now"

Explore Modern SharePoint Templates for 2024

Sharepoint Designs

Globus Compute Introduction - GlobusWorld 2024

Globus

2024 RoOUG Security model for the cloud.pptx

Georgi Kodinov

Prosigns: Transforming Business with Tailored Technology Solutions

Prosigns

Unlocking Business Potential: Tailored Technology Solutions by Prosigns Discover how Prosigns, a leading technology solutions provider, partners with businesses to drive innovation and success. Our presentation showcases our comprehensive range of services, including custom software development, web and mobile app development, AI & ML solutions, blockchain integration, DevOps services, and Microsoft Dynamics 365 support. Custom Software Development: Prosigns specializes in creating bespoke software solutions that cater to your unique business needs. Our team of experts works closely with you to understand your requirements and deliver tailor-made software that enhances efficiency and drives growth. Web and Mobile App Development: From responsive websites to intuitive mobile applications, Prosigns develops cutting-edge solutions that engage users and deliver seamless experiences across devices. AI & ML Solutions: Harnessing the power of Artificial Intelligence and Machine Learning, Prosigns provides smart solutions that automate processes, provide valuable insights, and drive informed decision-making. Blockchain Integration: Prosigns offers comprehensive blockchain solutions, including development, integration, and consulting services, enabling businesses to leverage blockchain technology for enhanced security, transparency, and efficiency. DevOps Services: Prosigns' DevOps services streamline development and operations processes, ensuring faster and more reliable software delivery through automation and continuous integration. Microsoft Dynamics 365 Support: Prosigns provides comprehensive support and maintenance services for Microsoft Dynamics 365, ensuring your system is always up-to-date, secure, and running smoothly. Learn how our collaborative approach and dedication to excellence help businesses achieve their goals and stay ahead in today's digital landscape. From concept to deployment, Prosigns is your trusted partner for transforming ideas into reality and unlocking the full potential of your business. Join us on a journey of innovation and growth. Let's partner for success with Prosigns.

Gamify Your Mind; The Secret Sauce to Delivering Success, Continuously Improv...

Shahin Sheidaei

Games are powerful teaching tools, fostering hands-on engagement and fun. But they require careful consideration to succeed. Join me to explore factors in running and selecting games, ensuring they serve as effective teaching tools. Learn to maintain focus on learning objectives while playing, and how to measure the ROI of gaming in education. Discover strategies for pitching gaming to leadership. This session offers insights, tips, and examples for coaches, team leads, and enterprise leaders seeking to teach from simple to complex concepts.

TROUBLESHOOTING 9 TYPES OF OUTOFMEMORYERROR

Tier1 app

Even though at surface level ‘java.lang.OutOfMemoryError’ appears as one single error; underlyingly there are 9 types of OutOfMemoryError. Each type of OutOfMemoryError has different causes, diagnosis approaches and solutions. This session equips you with the knowledge, tools, and techniques needed to troubleshoot and conquer OutOfMemoryError in all its forms, ensuring smoother, more efficient Java applications.

Recently uploaded (20)

Accelerate Enterprise Software Engineering with Platformless

First Steps with Globus Compute Multi-User Endpoints

Exploring Innovations in Data Repository Solutions - Insights from the U.S. G...

Understanding Globus Data Transfers with NetSage

Providing Globus Services to Users of JASMIN for Environmental Data Analysis

OpenFOAM solver for Helmholtz equation, helmholtzFoam / helmholtzBubbleFoam

Strategies for Successful Data Migration Tools.pptx

Globus Compute wth IRI Workflows - GlobusWorld 2024

De mooiste recreatieve routes ontdekken met RouteYou en FME

Climate Science Flows: Enabling Petabyte-Scale Climate Analysis with the Eart...

BoxLang: Review our Visionary Licenses of 2024

Innovating Inference - Remote Triggering of Large Language Models on HPC Clus...

Lecture 1 Introduction to games development

Visitor Management System in India- Vizman.app

Explore Modern SharePoint Templates for 2024

Globus Compute Introduction - GlobusWorld 2024

2024 RoOUG Security model for the cloud.pptx

Prosigns: Transforming Business with Tailored Technology Solutions

Gamify Your Mind; The Secret Sauce to Delivering Success, Continuously Improv...

TROUBLESHOOTING 9 TYPES OF OUTOFMEMORYERROR

The 6 Rules for Modernizing Your Legacy Java Monolith with Microservices

1. The 6 Rules for Modernizing Your Legacy Java Monolith with Microservices by Kevin Webber (@kvnwbbr)

2. ALegacyMonolith Story

10.

11.

12.

13. heritage architecture » Single points of failure » Impossible to scale out (shared mutable state, etc) » Different non-functional requirements (reads, writes, compute) » Optimized for none! » Long, risky release cycles

14. Howdo Microservices help?

15.

16.

17.

18.

19.

20.

21.

22.

23.

24.

25. Microservices » Ubiquitous language » Well deﬁned models & boundaries » Single responsibility » Independently deployable, scalable, resilient » Communicate via async messaging » Own their data » Don't expose a public API

26. Approach? Principles » responsive, resilient, elastic, message-driven

27. Approach? Principles » responsive, resilient, elastic, message-driven Concepts » bounded contexts (DDD), event sourcing, CQRS, CAP (eventual consistency)

28. Approach? Principles » responsive, resilient, elastic, message-driven Concepts » bounded contexts (DDD), event sourcing, CQRS, CAP (eventual consistency) Tools » Typesafe Reactive Platform (Play, Akka, Spark)

29. Conceptsand patterns We will cover: » Domain Driven Design (DDD) » Async messaging » API management » Dependency management » CQRS & event sourcing » Transactions & ordering

30. Domain Driven Design

31.

32.

33.

34.

35.

36. Getting started » Model sub-domain at package level » Tip: Visualize existing architecture with a tool like Structure101 » Deﬁne public RESTful API at package level (use async messaging inside package at service level) » Refactor for physical separation, remove package

37. Goingasync

38.

39.

40.

41.

42. Async Beneﬁts » Not wasting resources » Memory, CPU, threads » Embracing failure » Not expecting a return from a remote service » Designing for all scenarios

43. API management

44.

45.

46.

47.

48.

49.

50.

51.

52.

53.

54.

55. API mgmt. » Messaging patterns » Pub/sub, point-to-point, streaming » API gateway » Routing, aggregation, protocol translation » Discovery » Service discovery, registry, versioning

56. Dependencymanagement

57.

58.

59.

60.

61.

62.

63. CQRS & eventsourcing

64.

65.

66.

67.

68.

69.

70.

71.

72. Transactionsand ordering

73. Considerations » ACID doesn't work across location/trust boundaries » No 2-Phase commits (2PC) » No holding locks for the duration of work » In distributed systems we need to compensate for for failure rather than prevent failure

74.

75.

76. Whatnext?

77.

78.

79.

80.

81.

82. Microservices with Lightbend » Play for API gateway » Akka for core microservices (DDD, CQRS, event sourcing) » ConductR for cluster management (service registry, discovery, architecture visualization, security)

83. Lagom Monolithto microservices » Webinar: March 17, 1PM PST / 4PM EST » https://www.lightbend.com/discover-lagom » Ready-to-use connectors: event-sourcing, CQRS » Launch all microservices with a single command » Instantly visible code updates

84. Thankyou! Visit https://www.lightbend.com/products/lightbend- reactive-platform to get started Contactinfo » Twitter: @kvnwbbr » Email: kevin.webber@lightbend.com

85. LIGHTBEND REACTIVE PLATFORM  Full Lifecycle Support for Play, Akka, Scala and Spark Give your project a boost with Reactive Platform: • System orchestration for resilient releases • Real-time monitoring of asynchronous systems • Self-healing for network partitions, node and apps • Availability protected with configurable user quotas • Certified, load-tested Reactive Runtime Enjoy learning? See about the availability of on-site training for Scala, Akka, Play and Spark! GET STARTED

The 6 Rules for Modernizing Your Legacy Java Monolith with Microservices

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to The 6 Rules for Modernizing Your Legacy Java Monolith with Microservices

Similar to The 6 Rules for Modernizing Your Legacy Java Monolith with Microservices (20)

More from Lightbend

More from Lightbend (20)

Recently uploaded

Recently uploaded (20)

The 6 Rules for Modernizing Your Legacy Java Monolith with Microservices