Join Newsletter

Cloud Native Java Workshop (Online)

YOW! Workshops - 14 Aug

Register Now

Join YOW! Online for discounts on conferences and online workshops like this one - as well as great monthly content from our international expert speakers!


This online workshop will take place over two days, leaving time in between to work on exercises.:

Friday 14 August   9am - 1pm AEST |

Tuesday 18 August 9am - 1pm AEST


“It is not necessary to change. Survival is not mandatory.” -W. Edwards Deming

Work takes time to flow through an organization and ultimately be deployed to production where it captures value. It’s critical to reduce time-to-production. Software - for many organizations and industries - is a competitive advantage.

Organizations break their larger software ambitions into smaller, independently deployable, feature -centric batches of work - microservices. In order to reduce the round-trip between stations of work, organizations collapse or consolidate as much of them as possible and automate the rest; developers and operations beget “devops,” cloud-based services and platforms automate operations work and break down the need for ITIL tickets and change management boards.

But velocity, for velocity’s sake, is dangerous. Microservices invite architectural complexity that few are prepared to address. In this talk, we’ll look at how high performance organizations like Ticketmaster, Alibaba, and Netflix make short work of that complexity with Spring Boot and Spring Cloud.

In this workshop we'll look at how to build cloud-native applications that are destined for production. A cloud native application is:

  • elastic
  • agile
  • observable
  • robust

A cloud native application is one that is designed to fully exploit a cloud platform both in the application layer - where things decompose into microservices - and at the data layer where NoSQL offers better horizontal scaling and fitness for specific purposes. This is what we mean by elastic.

A cloud native application is one that is agile. It should be easy to write, change, test, deploy and operate. If the cost of change is prohibitive then normal people under normal situations won't do it. We must make doing the right thing - that which supports change - the easy thing.

A cloud native system is observable. It must support at-a-glance insight into what is happening in the system and support remediation. It must be instrumented at the application and systems levels to support the effort of crisis-management.

A cloud native application is one that is fault tolerant, or robust. If a service should fail, the system must be able to recover and degrade gracefully. Instead of trying to build a system that is predicated on the lie that things are highly available, build instead to optimize for time to remediation.

Josh Long

Spring Developer Advocate

Pivotal

United States

Josh is the Spring Developer Advocate at Pivotal. Josh is a Java Champion, author of 5 books (including O’Reilly’s upcoming Cloud Native Java: Designing Resilient Systems with Spring Boot, Spring Cloud, and Cloud Foundry) and 3 best-selling video trainings (including Building Microservices with Spring Boot Livelessons with Spring Boot co-founder Phil Webb), and an open-source contributor (Spring Boot, Spring Integration, Spring Cloud, Activiti and Vaadin).

Workshop Details

Target Audience
developers, Technical leads and Architects,programmers, testers, business analysts and product owners
Level
Advanced
Duration
Full day

Workshop Outline

In this workshop we'll cover:

 

  • Basics - we'll look at Spring Boot application development concepts like auto-configuration and embedded web container deployments (Spring Boot)

  • Reactive Programming - We'll look at how to build non-blocking, scalable reactive applications from Spring Framework to Spring Cloud and everything in between.

  • Kotlin - we'll use Java for tons of our examples, but there's a real opportunity for developers when building on top of the Kotlin programming language, particularly when we look at building reactive services

  • REST APIs - we'll look at concerns like API versioning and hypermedia. (Spring MVC, Spring Boot, Spring HATEOAS)

  • Data Access - we'll model a service domain and define bounded contexts. (Spring Boot, Spring Data)

  • Observability - what happens when there's a problem with your production application? How quickly can your team respond? How do you know if you're making improvements to a system? How do you measure progress? How do you monitor individual applications? How do you monitor the flow of requests through circuit breakers? How do you trace requests across the system? Can you visualize all the services in the system? We'll look at how to surface information about your services and systems. (Spring Boot Actuator, Micrometer, Graphite, Spring Cloud Sleuth, etc)

  • Testing - we'll look at the concepts of test-driven development. We'll cover unit testing individual components and mock them out. We'll look at how to test service interfaces. We'll look at how to write integration tests that don't sacrifice speed in order to be exhaustive using consumer driven contracts and consumer driven contract testing. (JUnit, Spring Boot, Spring MVC Test Framework, Spring Cloud Contract)

  • Routing and Load-Balancing - where does your service live? How do your clients find it? How do you handle custom routing requirements? How do you handle custom load-balancing? (Spring Cloud, Ribbon)

  • Message-driven and integration-centric architectures - We'll look at how to build microservices that talk to each other over messaging fabrics like Apache Kafka or RabbitMQ. We'll look at how to integrate existing systems and how to use messaging to connect disparate systems. (RabbitMQ, Spring Integration, Spring Cloud Stream)

  • Batch Processing - we'll look at how to process large amounts of sequential data and scale the processing across a cloud fabric. We'll look at how to scale processing horizontally as our processing needs demand. (Spring Batch, Spring Integration)

  • Reliability Patterns - we'll look at how to employ to build fault-tolerance into service invocations. We'll look at approaches to gracefully degrade if a service invocation should fail. 

  • Edge-services, API Gateways and API Adapters -  we'll look at how to build client-centric adapter APIs. and concerns like rate limiting, backends-for-front-ends, proxying, and other cross-cutting concerns. (Spring Cloud, Spring Cloud Gateway)

  • Security - we'll look at the concepts behind Spring Security and how to integrate it into our services. (Spring Boot, Spring Security OAuth, Spring Cloud Security)

  • Service Registration and Discovery - we'll look at how to register and discover services dynamically with a service registry like Netflix Eureka or Hashicorp Consul. (Spring Cloud)