Building Microservices in a green field environment is amazing! But the realities of some of our largest and oldest institutions is that there is a lot of value in existing legacy systems. When you're building on top of legacy systems, there are many challenges that green field development does not even have to consider. Join me for a 30 minute session in which we look at some patterns that we have employed over the last 2 years of building Spring Boot based microservices in the context of legacy systems. I'll speak to tried and true strategies for creating "strangler applications", strategies for moving away from the database as an integration point, and how to start carving off bounded contexts for your new microservices. I'll also speak to a handful of pit-falls to be avoided as you make the journey to a bootiful microservice landscape.
With the advent of ASP.NET Core, developers can now build cross-platform microservices in .NET. We can build services on the Mac, Windows, or Linux and deploy anywhere--most importantly to the cloud.
In this session we'll talk about Cloud Native .NET, building .NET microservices, and deploying them to the cloud. We'll build services that participate in a robust ecosystem by consuming OSS servers such as Spring Cloud Configuration Server and Eureka. We'll also show how these .NET microservices can take advantage of circuit breakers and be automatically deployed to the cloud via CI/CD pipelines.
The Java community is on the cusp of a major change in programming model. As the industry moves towards high-performance micro-service architectures, the need for a reactive programming model becomes clear. In this session, the lead developers of the Cloud Foundry Java Client will talk about what led them to choose a reactive API. Using that project as a lens, they'll explore how they designed and implemented this API using Project Reactor and what users will expect when using a reactive API. If you are a developer looking to provide reactive APIs, this is your chance to gain the experience of team building a large, production-ready reactive library.
DreamWorks Animation is a company that has historically thrived on taking advantage of cutting edge technologies and has more currently set its sights on further utilizing Microservices and the Cloud as part of its movie making process. This session will review the efforts that took place in both the initial phases which incorporated targeted parts of the Spring Framework, as well as more current efforts that leveraged Spring projects such as Spring Boot, Spring Data and Spring Cloud. Highlighted throughout the talk will be examples demonstrating the pros and cons of various approaches taken, including the social engineering aspects of changing a movie making culture to fully embrace what it means to adopt a Microservices platform.
Your existing message system is great, until it gets overloaded. Then what? That's when you should try Kafka.
Kafka is designed to be resilient. It takes the stress out of moving from a Spring monolith into a scalable system of microservices. Since you can capture every event that happens in your app, it's great for logging. You can even use Kafka's distributed, ordered log to simulate production load in your staging environment.
Come learn about Kafka, where it fits in your Spring app, and how to make it do things message queues simply can't.
Lambda expressions and the streams API add a more functional style of programming to Java; something developers have not really had in the past.
This session will start with a short summary of the key features of both Lambda expressions and streams before moving on to some real world examples of how to use them effectively, including a number of lessons learnt from trying to apply an imperative style of programming when it should have been functional.
We'll finish off with a quick look at some of the ideas for improvements to streams in JDK 9.
Leader election allows application to work together with other applications to coordinate a cluster leadership via a third party system. A leader can then be used to provide global state or global ordering, generally without sacrificing availability. In this presentation we show how Spring Cloud Cluster provides a simple abstraction for leader election and how it is implemented using zookeeper, hazelcast and etcd.
Apache Kafka is a distributed, scalable, high-throughput messaging bus. Over the last few years, Kafka has emerged as a key building block for data-intensive distributed applications. As a high performance message bus, Kafka enables the development of distributed applications using the microservices architecture.
Reactive Streams simplifies the development of asynchronous systems using non-blocking back pressure. The reactive framework enables the development of asynchronous microservices by providing a side-effect free functional API with minimal overhead that supports low latency, non-blocking end-to-end data flows.
After an introduction to Kafka and reactive streams, we will explore the development of a reactive streams interface for Kafka and the use of this interface for building robust applications using the microservices architecture.
In this session we will be presenting and coding a live Spring Boot-based application powered by Apache Geode (a.k.a. Pivotal GemFire) running on Cloud Foundry. Attendees will learn in-memory computing and data management concepts including data access and querying using Spring Data Repositories and GemFire OQL, complex/real-time event processing with GemFire CQs, data affinity using GemFire Functions conveniently implemented and executed with Spring Data GemFire Function annotation support and finally effective testing strategies and techniques for testing highly-concurrent, distributed applications using Spring's test framework along with JUnit, Mockito and MultithreadedTC.
This talk will use the seminal twelve-factor app essay as a guide to discuss the do’s and dont’s of building and running containers. Each factor gives us an opportunity to consider avoidable anti-patterns if you’re using containers to deploy and manage repeatable, reliable, and portable services.
Containers rose in popularity on an oft used metaphor: lightweight virtual machines. We have a robust understanding of the benefits of virtualized hardware as a method of efficient resource utilization. The idea of even more efficient resource utilization makes sense. Unfortunately it’s a problematic metaphor.
Containers represent a constrained set of capabilities compared to virtual machines in order to make fine-grained guarantees about resource constraints and process isolation. This is a good thing. There is overlap in ideal capabilities between VMs and containers but it isn’t complete. Newcomers to the container ecosystem begin with a “lightweight VM” understanding and fall victim to specific anti-patterns.
After this talk you’ll understand common pitfalls in containerization and how you can avoid them. This discussion is useful for developers who wish to gain greater understanding of the environment their applications are deployed to, as well as operators interested in the benefits of containers for their architecture.
Spring Boot DevTools is not the only new feature that boosts your productivity. During this live coding session, we’ll work on 10 common app features and see how Boot is making your life easier.
We’ll cover the following:
- Development cycle with Devtools, H2 Web console and persistent web sessions
- Manage custom error pages
- Managing application Cache
- Supporting OAuth2 in your app
- Using your custom AuthenticationPrincipal
- Using a persistent database in production
- Evolving your database schema with Flyway
- Custom Boot configuration (key hint, metadata)
- Gathering and exporting app Metrics
- Dealing with static resources in web apps
Enterprises going through the digital transformation want to leverage cloud for both legacy and greenfield apps – 2-speed. The Atos team will share their experience of building cloud automation and orchestration platforms, and how such platforms can help make cloud-based Spring and Cloud Foundry app development and deployment a consistent experience for all. We will show how we have helped leading enterprises rethink what it means and what it takes to function as a digital business. By putting the users at the heart of the new agenda, innovation begins to flourish creating exciting new opportunities.
Cloud Foundry is the foundation for cloud native applications to live and thrive. Our goal is to build this platform in an open community driving the momentum of a large scale project. In this talk you will learn about the current industry trends forming and how Cloud Foundry is working together around this in the open. You will also learn about contributions and where we see more and more of this taking place from single contributors to major companies and how this plays out.
An edge gateway is an essential piece of infrastructure for large scale cloud based services. This presentation details the purpose, benefits and use cases for an edge gateway to provide security, traffic management and cloud cross region resiliency. How a gateway can be used to enhance continuous deployment, and help testing of new service versions and get service insights and more are discussed. Philosophical and architectural approaches to what belongs in a gateway vs what should be in services will be discussed. Real examples of how gateway services, built on top of Netflix's Open source project, Zuul, are used in front of nearly all of Netflix's consumer facing traffic will show how gateway infrastructure is used in real highly available, massive scale services.
RESTful APIs are eating the world, yet all too often the documentation can cause indigestion for the APIs' developers and their users. Developers have to deal with annotation overload, repetition, and an unpleasant writing environment. Users are then left with documentation that's inaccurate and difficult to use. It doesn't have to be this way.
This talk will introduce Spring REST Docs and its test-driven approach to RESTful API documentation. We'll look at how it combines the power of Asciidoctor and your integration tests to produce documentation that's accurate and easy-to-read, while keeping your code DRY and free from annotation overload. We'll also look at some of the features that are new in Spring REST Docs 1.1, including support for REST Assured and Markdown.
The history of distributed systems deployment and orchestration is an epic tragedy of pain and loathing. The Cloud Foundry community has taken an alternative path, choosing an unorthodox strategy to deploy the complex distributed system powering the world's most successful open-source platform.
This talk examines the reasons behind that choice, examines the tooling at the heart of the new strategy, and looks at how you can use the tooling for your own distributed deployments. We will also review the latest developments and the intended roadmap for the "Marmite" of orchestration tooling - you either love it or hate it - BOSH.
Credential hygiene is a perennial concern in all distributed computing systems. It’s certainly of utmost importance in cloud-native platforms. It’s common practice to encrypt credentials for storage and distribution, but they ultimately need to be made available as cleartext to the application that requires them. In this talk, we will discuss the options available and best practices for these sensitive operations. Topics include: key encrypting keys, hardware security modules, and relatively new and promising advances in multi-party computation.
TDD introduced many improvements into the development process, but in our opinion the biggest impact relates to code design. Looking at the code from the usage perspective (by first writing an acceptance test) allows us to focus on usability rather than concrete implementation. Unfortunately, we usually rest on our laurels not trying to uplift this practice to the architecture level.
Consumer driven contracts (CDC) are like TDD applied to the API. It’s especially important in the world of microservices. Since it’s driven by consumers, it’s much more user friendly. Of course microservices are really cool, but most people do not take into consideration plenty of potential obstacles that should be tackled. Then instead of frequent, fully automated deploys via a delivery pipeline, you might end up in an asylum due to frequent mental breakdowns caused by production disasters.
This presentation will show you how you can use the Spring Cloud Contract Verifier functionality in order to have a fully automated solution to stub your HTTP / Messaging collaborators. Just by adding proper configuration you'll be able to have all of your microservices surrounding world faked with stubs that were tested against their producer.
We will write a system using the CDC approach together with spring boot, spring cloud and spring cloud contract verifier. I'll show you how easy it is to write applications that have a consumer driven API and that will allow a developer to speed up the time of writing his better quality software.
The goal of this session is to teach companies how they can use real-time data to make predictions with Spring Cloud Data Flow, Spark 2.0 and Spark ML. It will cover how to train your model using Spark ML in Spark 2.0. Once trained we will show you how to make real-time predictions using the model and Spring Cloud Data Flow.
In this session we will point out key differences in Spring XD that have been resolved in Spring Cloud Data Flow. We will highlight why we feel that Spring Cloud Data Flow has a much more promising future with it's real time analytics dashboard written in Spring. This session will also highlight Cloud Foundry and how it is used to quickly deploy and integrate new stream features.
What we cover:
- Best practices for streaming data
- Bus services for data point transport
- Stream scaling and development
- Feature cleansing, normalization, and transformation techniques
- Training and Validating models in Spark and Spark ML
- Monitoring your streaming applications in Cloud Foundry
In the microservice era, working with tens of hundreds of services leads to difficulties getting a grasp of the application health such as error frequency, server resources, response times and throughput. It is said visualization tools can help us command a view of the whole system and detect problems in the early stages or prevent them from occurring, but the important thing is to choose proper tools and create dashboards the right way.
This session offers techniques for visualizing microservices built by Spring Boot applications using Elasticsearch, Kibana and Spring Cloud Sleuth. Besides visualizing server resources and access logs, service dependencies and performance bottlenecks, and business statuses such as conversion rate are also visualized. Let's have fun diving into visualizing your applications.
This talk covers a strategy for migrating 100s of legacy .NET apps and new .NET core apps to CF in the enterprise. It includes a discussion on the implications of giving up AD, leveraging lifecycle management with BOSH, the advantages of .NET core on Linux, and the realities of billions of lines of legacy .NET.
Project Jigsaw will bring modularity to the Java platform; something that will enable better security, performance and flexibility for deployment of applications. This talk will look at the fundamentals of how modularity in Java will work. Developers will need to understand that these changes go significantly further than just separating the standard class libraries into a number of discrete units.
This talk will explain the impact project Jigsaw will have on developers in terms of building their applications, as well as helping them to understand how things like encapsulation of private APIs, which have up until now been visible, will change in JDK 9.
The past few years have been a time of disruption in the healthcare industry, with new federal mandates and nimble entrants into healthcare payor market. Find out more about how Healthcare services Corp, the parent company of a 5-state Blue Cross Blue Shield organization, has evolved and retooled in 6 months to become digital-first, and maintain their strong leadership in the industry. Efforts which typically would have taken a year's worth of time and resources to create were completed in 5 weeks because of new development methodologies and technology, including Spring, microservices, and Pivotal Cloud Foundry. Discover how developers have become empowered to be more focused, to work intelligently in a lean fashion, and to understand the organizational experiences of co-locating with the business.
IDEs can be powerful, but hard to learn. Some features are hidden or simply not well known.
Let’s end this dilemma and make you more productive and efficient when working on Spring applications. Learn how to navigate, edit and perform refactorings across a variety of common Spring technologies.
You’ll leave this session with a whole stack of power tricks - right from the developers working on it.
Spring Data REST provides a solid foundation to build domain-driven REST webservices leveraging hypermedia. It takes away the boilerplate part of the development and allows you to concentrate and easily hook code to cover more advanced scenarios, like custom state transitions. The talk is going to look into which means the library provides to easily integrate manually coded REST resources, tweak representations and work with lookup types (database backed value types) and especially focusses on the features added in recent releases.
Microservices architecture elevates the challenges for Authentication and Authorization management. When a single frontend request can result in many backend microservices calls, it is important to balance security and performance. ForgeRock provides a standards-based blueprint that provides a flexible solution for making these choices while protecting your Cloud Foundry services end to end.
Web development has become more complex in the last few years with a plethora of frameworks to choose from and no clear direction. Join Sergi Almar in this presentation to learn why Angular2 is a good fit for Spring developers. We'll review the Angular2 architecture and see how TypeScript allows us to build more maintable and clean applications having the benefits of a typed language. We'll look at the Angular2 component based model, dependency injection, data binding, routing, templates...to build modern web applications.
No prior AngularJS knowledge is required.
In this talk we will demonstrate how GitLab helps developers along their entire workflow from first commit, issue tracking, continuous integrations, and deployment into Pivotal Cloud Foundry for production services.
Learn how to build scalable, self-sustaining Embedded Ecosystems powered by small-scale Renewable Energy (solar, wind) systems, connect those systems to cloud services, and monitor & control them from your desktop, mobile device...or wearable!
This session introduces you to IoT & Cloud concepts and demonstrates how one necessitates the other.
What do things like Minecraft, a light bulb and your music library have in common? Well, nothing really. Until you come up with this crazy idea to link them together. This is where application orchestration comes in.
In this session, you’ll learn how Spring Cloud Data Flow allows easy composition of microservices together. As the spiritual successor to Spring XD and the natural sidekick of Spring Cloud Stream, Data Flow has been thought as a way to deploy, run and manage loosely coupled apps in the cloud.
Spring Integration has long captured the hearts and minds of the developers world wide for its emphasis on simplicity, modularity and productivity when it comes to all things related to work-flow orchestration and complex event processing and is successfully used in a variety of Big Data solutions. Apache NiFi, on the other hand, is a new addition to the already rich Big Data technology stack.
Can the two complement one another?
This hands-on talk, based on real field work and consisting of live demos and code, will provide a quick introduction to Apache NiFi, demonstrate its core features while concentrating on the WHY/WHERE and HOW of integrating the two technologies.
The Gap is rapidly adopting Cloud Foundry. As part of that adoption, our developers are adapting to a new set of patterns, tools and processes. This talk focuses on what patterns worked for us in considering integration, messaging, data, scaling, and other concerns. We’ll share what we've learned, how we’re rapidly delivering new capabilities with Cloud Foundry and where we’re headed next.
Anyone who is actively using Spring must have heard of Spring Boot by now. It is the current de facto standard tool to start with a new Spring project and will become even more prevalent over the coming years.
Next to an easy to use interface at start.spring.io and very good documentation, there are a ton of so called Spring Boot Starters which a developer can use to jumpstart their development.
While the auto-configuration and starters often seem to be magically endowed creatures originating from the deepest regions of the forest moon of Endor... there are not.
In fact, anyone can write his or her own Spring Boot Starter.
During the presentation, I will explain the inner workings of a Spring Boot Starter project and go over the necessary code for creating our own. I will use my recently developed starter for integrating Spring Social with a Redis backed datastore.
At the end of the session, the audience will know that the Spring Boot autoconfiguration and starter projects are not magical unicorns, but easy to understand components in the Spring Boot ecosystem. They will also learn how to create their own Spring Boot Starter project and hopefully, they will be inclined to become proactively involved in the Spring Boot project.
Everyone has the question of how to continuously deliver; we have an answer that extends past the application to the platform itself.
Deploying and updating Pivotal Cloud Foundry to your infrastructure can be a complicated process if performed manually. Automation and predictability are two important criteria for any mature operations organization. This talk focuses on lessons learned while building our continuous integration pipeline for deploying Pivotal Cloud Foundry to production. It will demonstrate how the commitment of the team towards operating Pivotal Cloud Foundry in a mature way matters more than the specific tools we used. The talk will cover a year’s journey of refining the process for updating a Pivotal Cloud Foundry deployment. I will present a case study of how different manual processes and automated processes converged into what we have today.
The talk will focus on the different approaches we tried and elaborate on the details of the approach that has worked for us. The audience will leave with actionable takeaways in their pursuit of a continuously delivered platform.
Despite the plethora of open security standards and drafts, there is a dearth of comprehensive solutions that satisfy the requirements of RESTful access control in the industrial space. Standards like OAuth 2.0, geared towards consumer-facing applications, have gained wide support but only provide mechanisms for coarse-grained authorization. Newer standards like UMA build logical extensions to OAuth that allow for finer-grained access control but mention nothing about how to define policies and manage privileges. XACML-based solutions thrive in the enterprise but they are costly and have a steep learning curve. In this talk we will explore a novel solution to the problem of building access control for RESTful services in the industrial world.
As organizations move to audit trails over managed processes, continuous delivery with aggressive MTTR, security first doctrines and ephemeral instances, a key enabler is a platform ability for dynamic application configuration and securely bootstrapping application secrets. In this session, we will go over what the use cases for dynamic configuration and application secrets management are with some high level requirements, how we are collaboratively solving for these at enterprise scale using Spring Cloud Config, Vault and Consul and what’s coming next.
The primary goal of the Spring Data project is to make it easier to build Spring-powered applications that use data access technologies.
In this talk, Neil and Viktor will present using a new Spring Data for Hazelcast project and demonstrate how using the Spring Data paradigm gains the power of a distributed data repository.
The implementation is built on the new Spring Data KeyValue module and is one of the first projects to do this. This module provides infrastructure components for creating repository abstractions for stores dealing with Key/Value pairs like java.util.Map or Hazelcast IMap.
Through the means of the repository interface, CRUD operations and expression-based query methods can interrogate an in-memory data store in a manner consistent with the other Spring Data projects so developers can become productive quickly and easily.