Stay productive while slicing up the monolith

The Marketplace data team at Uber has built a scalable complex event processing platform to solve many challenging real-time data needs for various Uber products. This platform has been in production for more than a year and supports over 100 real-time data use cases with a team of 3. In this talk, we will share the detail of the design and our experience, and how we employ Siddhi, Kafka and Samza at scale.

This document provides an overview of microservice architecture (MSA). It describes the characteristics of MSA, including small, independent services focused on a single business capability. It covers service interaction styles, service discovery, data management challenges in MSA, deployment strategies, and migration from monolithic to MSA. It also discusses event-driven architecture, API gateways, common design patterns, and challenges with MSA.

This document discusses moving from monolithic applications to microservices architectures. It begins by defining monolithic applications and how they can become difficult to scale. It then introduces the concepts of decoupling applications and microservices as an architecture where independent processes communicate via APIs. Some benefits discussed are improved scalability, release cycles, and fault tolerance. The document provides examples of microservices for tasks like text search and recommendations. It concludes by recommending starting with a monolithic approach and refactoring to microservices as needs require for scalability.

This document discusses prerequisites for using Tomcat and MySQL including having a Java Developer Kit (JDK), Eclipse IDE, Tomcat application server, an Azure subscription, and the Azure plugin for Eclipse. It also mentions provisioning role instances, deploying application code, configuring networks, using a distributed cache, monitoring application health and availability using metrics and alerts, and automatically scaling applications using auto scale rules in Azure.

Containers brought new approach for implementation of DevOps workflows. So our CEO, Ruslan Synytsky, devoted a speech to this topic during Madrid meetup and described in details how Java developers can get benefits from Docker containers in Jelastic Cloud.

This document summarizes 12 key things to know about Oracle WebLogic Server 12c. It discusses the new lightweight installer, per domain node manager, server templates, dynamic clusters, unified management APIs, Java Mission Control monitoring, built-in WLDF modules, RESTful management APIs, Java EE 7 support, new Maven goals, and using WebLogic with Docker containers. The presentation provides an overview of new and updated features in WebLogic 12c and highlights reasons to upgrade from previous versions.

Nowadays "cloud" and "microservice" terms are used all the time, even overused. Does any system must be the "microservices" deployed in the "cloud"? Definitely not! However once you see that your system may benefit from that architecture, the next question is how to get there - how to fly to the clouds? Spring was always about simplifying the complicated aspects of your enterprise system. Netflix went to microservice architecture long before this term even was created. Both are very much contributed to open source software. How can you benefit from joint forces of the both?

Nowadays "cloud" and "microservice" terms are used all the time, even overused. Does any system must be the "microservices" deployed in the "cloud"? Definitely not! However once you see that your system may benefit from that architecture, the next question is how to get there - how to fly to the clouds? Spring was always about simplifying the complicated aspects of your enterprise system. Netflix went to microservice architecture long before this term even was created. Both are very much contributed to open source software. How can you benefit from joint forces of the both?

Java Byte code is OS independent, which means that your application's startup takes more time than a native image. Using the Class Data Sharing functionality introduced in more recent versions of the JVM, you can prepare your application so that it will load very fast. In this presentation, I'll go into more detail what Class Data Sharing is and the differences between the OpenJDK and OpenJ9 versions. With some Jakarta EE demo applications, you will see gains that you can achieve and reduce memory footprint a lot in Docker containers by sharing memory.

This document summarizes the evolution of cloud computing technologies from virtual machines to containers to serverless computing. It discusses how serverless computing uses cloud functions that are fully managed by the cloud provider, providing significant cost savings over virtual machines by only paying for resources used. While serverless computing reduces operational overhead, it is not suitable for all workloads and has some limitations around cold start times and vendor lock-in. The document promotes serverless computing as the next wave in cloud that can greatly reduce costs and complexity while improving scalability and availability.

The document outlines the roadmap and vision for Cloud Foundry, including: - The mission is to create an open source PaaS with a thriving ecosystem that allows for continuous delivery and an agile experience. - The vision includes features like instant routing, log aggregation, metrics/telemetry, access controls, high availability, and extensibility. - Key areas of focus are applications, services, and the platform (BOSH). This includes features for application policy, routing, runtime, logs/metrics, and identity/security. - The roadmap is agile but focuses on areas like the Diego project, Docker support, .NET runtime, loggregator improvements, and service

Presentation delivered at JavaOne 2010. Talks about how to use Java to build highly scalable and reliable applications on Windows Azure.

WSO2 Carbon provides extension points that allow customization. Sam is evaluating WSO2 middleware for PhotographersRUs and has several questions. WSO2 products can be configured to support single sign-on through the authenticators.xml file. User stores can also be customized or replaced to support PhotographersRUs' multiple user stores. Deployments can be synchronized across a cluster using the repository deployment directory. Monitoring is supported through valves, ESB mediators, and WSO2's Business Activity Monitor. The ESB can integrate new retail POS systems using transports, formats, listeners and builders.

The document discusses leveraging Azure and Cello to build scalable multi-tenant SaaS solutions. Cello provides a framework for developing SaaS applications that can be deployed on Azure. It includes features for engineering, operations, and subscription management. Using Cello with Azure allows applications to benefit from Cello's SaaS capabilities and Azure's infrastructure management and scalability. ISVs can build applications that can easily scale on Azure to serve growing numbers of customers.

Watch this on-demand webinar on database proxies (for MySQL) by Gilles Rayrat, VP of Engineering at Continuent. Gilles is one of the most knowledgeable experts in the MySQL community when it comes to database proxies and shares some of his knowledge in this initial webinar on that topic. From a simple database connectivity scenario all the way through to advanced database connectivity setups and proxy functionalities, this webinar provides an in-depth introduction to database proxies (for MySQL). AGENDA - A simple database connectivity scenario - The concept of a clustered database - Failure in a clustered database: the nightmare scenario - The solution: use a proxy! Preferably a smart one … - Advanced database connectivity setups - Advanced proxy functionalities - Recap SPEAKER Gilles Rayrat, VP of Engineering, Continuent, has over 20 years experience in software engineering. Previously holding positions at Orange and Xerox, he joined the Continuent adventure in 2005. As the connectivity expert at Continuent, he has worn many hats including software development, QA, support, project and operations management. Gilles has held most of the engineering positions that he now manages, giving him both deep and wide experience.

In this slidecast, Yoram Novick from Maxta describes the company's new software-defined, VM-centric Storage solutions. "The complexities and high costs of traditional enterprise storage are magnified in the virtual data center," said Yoram Novick, Founder and CEO of Maxta. "After being told repeatedly that expensive storage arrays are the only way to support enterprise applications in virtualized environments, IT organizations finally have an alternative to storage arrays that significantly reduces complexity and cost. Maxta has broken the code for integrating storage and compute into a converged virtual data center." Learn more: http://maxta.com Watch the video presentation: http://wp.me/p3RLEV-1wl

DC/OS is an open source platform that provides container orchestration and management using Mesos. It allows running applications and services across data center infrastructure including bare metal, VMs, and cloud. DC/OS provides services like Marathon for container orchestration, security, monitoring, load balancing and service discovery. It has features like high resource utilization, mixed workload support, elastic scalability, high availability and zero downtime upgrades.

This document discusses CQRS and event sourcing patterns for Java developers. It begins with an overview of classical monolithic architectures versus modern microservice architectures. It then contrasts CRUD with CQRS, explaining that CQRS separates reads from writes by using commands for writes and queries for reads. Events evolve from commands and represent things that occurred in the past. The document provides an example implementation using the Lagom framework that demonstrates separating the write side from the read side and persisting events. It emphasizes that with this approach, all state changes are stored as events and the current state can be recreated by replaying events. The document encourages the use of Lagom due to benefits like asynchronous programming, developer productivity, and production readiness.

Kirk Marty, Enterprise Sales Engineer at Mesosphere introduction to Hyperscale Computing, Enterprise Agility at Lightbend's Chicago Reactive Roundtable. Learn more: lightbend.com/reactive-roundtable

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.

Social media is great. Being in contact with people from all over the world and being able to help your community from everywhere is nothing short but amazing. Yet, there are a few things to keep in mind to use these tools to their full extend without failing. This session introduces you to some very basic communication skills and walks you through the 10 golden rules in social media.

This document summarizes a talk about using Sinatra and RestClient for building lightweight web services and clients. Sinatra provides a simple and lightweight way to build web applications compared to full-featured frameworks like Rails. RestClient provides a simple way to make HTTP requests from client applications, offering more functionality than Net::HTTP but with less complexity than ActiveResource. Examples of Sinatra and RestClient use include a Git wiki application built in 355 lines of Ruby code and a Heroku client library.

This document provides an introduction and overview of NoSQL databases. It discusses that while NoSQL databases were created to solve specific pain points around scaling large amounts of data, many situations do not actually require a NoSQL solution. It then covers some common distribution models for NoSQL databases like replication, sharding, and consistent hashing, and provides examples of companies that developed NoSQL databases to solve their particular data problems.

One microservice is not enough and microservices should be built as systems. Building a single microservice is generally easy, but building a system of microservices that are integrated is challenging due to increased complexity from deployment, large development teams, and separating functionality from monolithic applications. The Lagom framework is designed to help with building microservice systems by providing an opinionated development environment, service API, and persistence API to address these challenges.

Apache Camel is one of the most complete integration frameworks out there. With more than 150 components and a large community it clearly has it's fans. Deploying the lightweight core is easy. Getting into modules and even more components makes this challenging. There are different approaches to ride that Camel. How to get the most out of it with Java EE and WildFly is exactly the topic of this session. It will introduce you to both Java EE 7 and Apache Camel in a very brief way and follows up with the different integration and deployment scenarios along with introducing the tools which help you the most on the way to your integration solution.

The document provides examples of Apache Camel route configuration using Java DSL, XML DSL, and code snippets. It demonstrates how to configure routes that use choice/when logic to route messages to different endpoints based on message properties or content. It also includes links to Apache Camel documentation on core concepts like components, data formats, languages, and how to download, use IDE tools, and deploy Camel applications on servers like WildFly.

Build Android OS on OS X requires setting up a large virtual disk image for the build files, installing necessary build tools like Git and Python, initializing the source code repository with Repo, syncing the source, and building with Make. CCache can be used to speed up incremental builds by caching object files but it is not recommended to build Android on Mac due to performance and compatibility issues.

The future of scalable data processing is event-driven microservices! They provide a powerful paradigm that solves issues typically associated with distributed applications such as availability, data consistency, or communication complexity, and allows the creation of sophisticated and extensible data processing pipelines. Building on the ease of development and deployment provided by Spring Boot and the cloud native capabilities of Spring Cloud, the Spring Cloud Stream project provides a simple and powerful framework for creating event-driven microservices. They make it easy to develop data-processing Spring Boot applications that build upon the capabilities of Spring Integration. At a higher level of abstraction, Spring Cloud Data Flow is an integrated orchestration layer that provides a highly productive experience for deploying and managing sophisticated data pipelines consisting of standalone microservices. Streams are defined using a DSL abstraction and can be managed via shell and a web UI. Furthermore, a pluggable runtime SPI allows Spring Cloud Data Flow to coordinate these applications across a variety of distributed runtime platforms such as Apache YARN, Cloud Foundry, Kubernetes, or Apache Mesos.

This document compares and contrasts message buses and service buses. A message bus allows modules to communicate by sending requests without knowing the destination, and supports replacing or adding providers without impacting other modules. However, modules using a message bus require a common data format. A service bus also allows loosely coupled communication between modules. Additionally, it supports modules communicating even if they use different data formats, through the use of data transformers. This means modules can be switched or changed without requiring other modules to change. However, a service bus is more complex than a message bus and may be overkill for small applications.

Reactive applications are becoming a de-facto industry standard and, if employed correctly, toolkits like Lightbend Reactive Platform make the implementation easier than ever. But the design of these systems might be challenging as it requires particular mindset shift to tackle problems we might not be used to. In this talk, we’re going to discuss the most common things I’ve seen in the field that prevented applications to work as expected. I’d like to talk about typical pitfalls that might cause troubles, about trade-offs that might not be fully understood or important choices that might be overlooked including persistent actors pitfalls, tackling of network partitions, proper implementations of graceful shutdown or distributed transactions, trade-offs of micro-services or actors and more. This talk should be interesting for anyone who is thinking about, implementing, or have already deployed a reactive application. My goal is to provide is to provide a comprehensive explanation of common problems to be sure they won’t be repeated by fellow developers. The talk is a little bit more focused on Lightbend platform but the understanding of the concepts we are going to talk about should be beneficial for everyone interested in this field.