Spring I/O 2017

Spring I/O 2017 (18-19 May, Barcelona) is a two day event focused on the Spring Framework ecosystem www.springio.net

Spring I/O 2017 - 18 -19 May, Barcelona GitHub repo: https://github.com/snicoll-demos/demo-webflux-streaming Software exists in an ever-changing environment that places new demands on the code we're writing and the code we've already written. In this talk we'll look at how Spring adapts to these demands and how it can help your code to adapt as well.

Spring I/O 2017 - 18 -19 May, Barcelona Spring Framework 5.0’s major theme is Reactive Programming support, specifically, Reactive Streams. To fuel that revolution, the same OSS teams behind Spring and RxJava are working on an independent reactive engine: Project Reactor. In fact, it’s supporting a wide range of reactive new features from Spring MVC to Spring Data, Spring Cloud Streams, or even Kafka, Netty and Cloud Foundry orchestration (!). This session introduces Reactor 3 with practical examples. It will show how to write and test reactive applications or APIs that are backpressure-ready and resilient by design, going from callback hell to reactive well.

Spring I/O 2017 - 18 -19 May, Barcelona As a giant and fast growing cross border b2c e-commerce business, AliExpress heavily relies on Microservices to keep its speed and stability. In this talk I will introduce: 1. How we integrate Spring Boot to Alibaba infrastructure services. 2. How we use BOM to manage dependencies. 3. How we integrate Spring Cloud Config to Alibaba configuration service. 4. Patterns we found as we write dozens of Spring Boot starters.

Spring I/O 2017 - 18 -19 May, Barcelona This talk will provide an Architectural Overview of Spring Security with a focus on Authentication and Authorization. The main goal is to empower users with a deeper knowledge of how Spring Security works “under the covers”. This talk will also demo various Authentication and Authorization scenarios.

Spring I/O 2017 - 18 -19 May, Barcelona GitHub repo: https://github.com/michael-simons/bootiful-databases jOOQ is one of several quite different technologies to access relational data from Java based applications. jOOQ is short for "Java object oriented querying" and describes a query builder framework that takes a look at your database schema, independent wether you use an Open Source database like PostgreSQL or an commercial product like Oracle Database., and provides you with a domain specific language (DSL) for generating statements. jOOQs goal is explicitly not to shield the user from SQL but providing a type safe way to use it. Learn in this session who you can facilitate the "magic" of Spring Boot to provide jOOQ with needed resources and then use it to publish advanced analytic queries as HTTP apis. Along the way you learn how automatic database migrations help you to do continuous delivery even with database centric applications.

Spring I/O 2017 - 18 -19 May, Barcelona Slides: https://www.slideshare.net/asotobu/testing-for-unicorns-77069262 One of the most important benefits of automated testing is to ensure a fast and safe code refactoring to evolve our system architecture. The main problem is how to write tests that are easy to write, easy to follow and not time consuming during development nor execution time. In this session, we are going to explore some powerful Java testing libraries that will help you write better (unit) tests focusing on the main Unicorns architecture challenges such as validating microservices endpoints, remote calls to other microservices or just asynchronous/reactive code.

Spring I/O 2017 - 18 -19 May, Barcelona Slides: https://www.slideshare.net/JeroenSterken1/the-spring-ecosystem-in-50-min There are currently over 20 main projects, most of them containing multiple subprojects. Do you know each one of them? Probably not. In this session we have only 1 main goal, taking a bird’s-eye view on all of them. I know, this will get challenging, but afterwards you’ll hopefully discover those projects that you never thought existed. Let’s dive in!

Spring I/O 2017 - 18 -19 May, Barcelona Slides: https://www.slideshare.net/mraible/front-ends-for-back-end-developers-spring-io-2017 Are you a backend developer that’s being pushed into front end development? Are you frustrated with all JavaScript frameworks and build tools you have to learn to be a good UI developer? If so, this session is for you! We’ll explore the tools of the trade for fronted development (npm, yarn, Gulp, Webpack, Yeoman) and learn the basics of HTML, CSS, and JavaScript. We’ll dive into the intricacies of Bootstrap, Material Design, ES6, and TypeScript. Finally, after getting you up to speed with all this new tech, we’ll show how it can all be found and integrated through the fine and dandy JHipster project.

Spring I/O 2017 - 18 -19 May, Barcelona Slides: https://speakerdeck.com/ryanjbaxter/beginners-guide-to-spring-cloud You have heard and seen great things about Spring cloud and you decide it is time to dive in and try it out yourself. You fire up your browser head to Google and land on the Spring Cloud homepage. Then it hits you, where do you begin? What do each of these projects do? Do you need to use all of them or can you be selective? The number of projects under the Spring Cloud umbrella has grown immensely over the past couple of years and if you are a newcomer to the Spring Cloud ecosystem it can be quite daunting to sift through the projects to find what you need. By the end of this talk you will leave with a solid understanding of the Spring Cloud projects, how to use them to build cloud native apps, and the confidence to get started!

Spring I/O 2017 - 18 -19 May, Barcelona The last couple of years we have been adopting Microservices but mainly for our backend services. When thinking of the frontend we most of the time end up with a monolithic web application which utilizes our modulair backend. In this talk we will explore how we could use microservices to our advantage and also split up our frontend so that we can leverage the full power of microservices in both the backend and frontend. We will explore how the use of some JavaScript techniques combined with progressive enhancement and following web standards help us in creating a modular / Composite UI.

Spring I/O 2017 - 18 -19 May, Barcelona GitHub repo: https://github.com/poutsma/web-function-sample In Spring 5, we introduced a new, functional web framework, next to the existing annotation-driven programming model. In this talk, we will discuss this new framework: how it is used, what its goals are, how it compares to the annotation model, and other related topics.

Spring I/O 2017 - 18 -19 May, Barcelona Although security and identity management is a crucial aspect for any application, its implementation can be difficult. Worse, it is often neglected, poorly implemented and intrusive in the code. But lately, Identity Management servers has appeared which allow to outsource and delegate all authentication and authorization aspects, such as https://auth0.com/. Of these servers, one of the most promising is Keycloak, open-source, flexible and agnostic of any technology, it is easily deployable / adaptable in its own infrastructure. In this session, I propose you to discover KeyCloak progressively and in an interactive way: 0 slide, 100% live coding. We will naturally focus on the Spring Boot adapter that Keycloak provides but also see how you can combine Spring Security with Keycloak.

Spring I/O 2017 - 18 -19 May, Barcelona We'll start with a review on recent advances in Deep Learning. Then we'll present DeepLearning4J (the first commercial-grade, open-source, distributed deep-learning library written for Java) and explore how it covers topics explained in the initial review. We'll then present a Spring Boot application with some functionality run by a Neural Network. Finally we'll explore the possibilities of implementing a Supervised Learning System using Spring Boot Actuator, which will lead to a trained monitoring system that can be interacted with actuator endpoints.

Spring I/O 2017 - 18 -19 May, Barcelona When you’re building microservices, managing state becomes a distributed systems problem. Instead of being able to manage state as transactions inside the boundaries of a single monolithic application, a microservice must be able to manage consistency by using transactions that are distributed across a network of many different applications and databases. Event-driven architectures are a key component of solving data consistency issues in microservices. This session explores the problems of data consistency in microservices and the various event-driven practices that include CQRS and Event Sourcing. We will look at how these popular practices are implemented using Spring Boot and Spring Cloud Stream.

Spring I/O 2017 - 18 -19 May, Barcelona Slides: https://docs.google.com/presentation/d/1tRWUJnGCGMbYjB11koaOukgzD-zNB8MaimeoFPJ2_JQ/edit In the era of Docker, big data and microservices it is really important to distribute your applications reasonable across your cluster and keep a good overview of all of your running applications. Because of this, cluster management software like Apache Mesos and DC/OS are very important and popular. In this session we will implement a java based service using spring boot and will start him locally and with docker-compose. Then we will deploy our service to DC/OS and see how easy it is to scale, upgrade, monitor and do other fancy stuff. And the best thing for the demo: We will have a nice UI and super cool CLI.

Spring I/O 2017 - 18 -19 May, Barcelona JHipster (https://jhipster.github.io/) is a widely-used, Open Source application generator platform for creating Spring Boot + Angular projects in minutes! JHipster can generate simple web app to complex microservice architectures in a breeze. JHipster comes packed with tools, tips and ideas to make you generate, code and deploy your application faster than you thought it was possible. Deepu KS (JHipster project co-lead) will take you through and show how to create full fledged Spring boot webapp with Angular 4, Bootstrap 4 and Webpack from scratch using JHipster 4.0 and deploy it to production under 30 minutes

Spring I/O 2017 - 18 -19 May, Barcelona Slides: https://speakerdeck.com/mploed/ddd-strategic-design-with-spring-boot-examples One of the most precious parts of Domain Driven Design are the concepts of Strategic Design. These concepts include the Bounded Context, the Context Map and the patterns that are being documented in the Context Map. This talk explains all of the topics mentioned above as well as practical usage scenarios such as migrating a monolithic landscape to Microservices. In order to get hands-on I will also demonstrate the concepts surrounding Strategic Design with an application landscape of various Spring Boot Applications.

Spring I/O 2017 - 18 -19 May, Barcelona Slides: https://speakerdeck.com/andreasevers/awesome-tools-to-level-up-your-spring-cloud-architecture-1 Getting up and running with Spring Cloud is a breeze. But once the initial setup is done, it needs to be complemented with an ecosystem that can cope with the extra operational complexity and quality concerns. While running Spring Cloud in production for years, we have integrated some interesting tools for documentation, operations and testing. During this talk you will see a demo of an integrated platform based on Spring Cloud, including tools like Spring Cloud Contract, wiremock, saboteur, ELK, Spinnaker, Spring Boot Admin and more. One of these tools is a dashboard for visualising Spring Cloud microservice architecture, which has recently been open sourced. Documenting, testing, troubleshooting, and monitoring highly distributed systems in microservice architectures is hard. Finding quality, complementary tools in the wilds of open source can be even harder. Join this talk for a pragmatic look at taming some of the challenges of running microservices in production.

Spring I/O 2017 - 18 -19 May, Barcelona Slides: https://www.slideshare.net/StevePember/surviving-in-a-microservices-environment Cloud Native Microservice architectures have become increasingly popular over the past few years, and for good reasons: smaller, efficient codebases, finely targeted scaling options, and the ability to do continuous deployment along with continuous integration, among others. All potentially very powerful features. However - as with most things - Microservices bring tradeoffs in terms of application complexity: working with an individual service is easy; overall application development becomes increasingly complex. Perhaps too complex for your average web application. Many presentations on the Microservice phenomena offer either a high level view on what it is, compare and contrast it with the Monolith pattern, or discuss how to migrate from a Monolith to Microservices, but rarely does one hear what it’s like to actually work in such an environment. Frankly, it can be intimidating for someone accustomed to a traditional monolithic development experience. Individual services are somewhat trivial to develop, but now you suddenly have countless others to keep track of. You may become lost: with all these services, is anyone directing the overall development? You’ll become obsessed over how and when they communicate. You’ll have to start referring to the application on the whole as “the Platform”. It’ll soon become difficult or even impossible to run the whole Platform on a development laptop. You may even have to take on some DevOps work, and start learning about deployment pipelines, and whole new worlds of metrics and logging. Don’t panic. In this presentation we’ll discuss what we learned working with a Microservice platform for the past three years. We’ll cover what to expect when joining a Microservice team and what the situation will look like as the team size grows. We’ll see how critical inter-service testing strategies are to the success of the team. We’ll examine what a development lifecycle might look like for adding a new service, developing a new feature, or fixing bugs. We’ll dive a bit into DevOps and see how one will become dependent and various metric and centralized logging tools, like Kubernetes and the ELK stack. Finally we’ll talk about communication, team organization strategies, and how they are likely the most important tool for surviving a Microservices development team.

Spring I/O 2017 - 18 -19 May, Barcelona Reactive web apps are the here now with their fancy flows, promises of scalability and horrible debugging experiences. We’ll show them a business UI or two. Outline: * Properties of reactive UI’s * Simple reactive UI with server-side Java * Simple reactive UI with Polymer web components

Spring I/O 2017 - 18 -19 May, Barcelona Spring 5 is almost here! One of the most exciting introductions in this release is support for reactive programming, building on Pivotal's Project Reactor to support message-driven, elastic, resilient, and responsive services. Spring 5 integrates an MVC-like component model adapted to support reactive processing and a new type of web endpoint, functional reactive endpoints. In this talk, we'll look at the net-new Netty-based web runtime and how to integrate it with existing Spring-stack technologies.

Spring I/O 2017 - 18 -19 May, Barcelona Live coding and demos! In this presentation you'll learn what Spanner is all about, how to setup you first instance and database. We walk through design decisions when coming up with your first schema and queries that are enabled to scale to terabytes of data. Come prepared to see some code, queries and query explains

Spring I/O 2017 - 18 -19 May, Barcelona GitHub repo: https://github.com/mminella/data-microservices When the word “microservice” comes up, many thoughts go directly to REST endpoints powering websites. However, applying the 12 factor concepts to batch and integration style workloads can provide immense benefits. In this talk, we will walk through creating data microservices for both streaming applications (integration) via Spring Cloud Stream as well as short lived microservices via Spring Cloud Task. We’ll finish by looking at how Spring Cloud DataFlow can be used to orchestrate these microservices into useful applications. A general knowledge of Spring and Spring Boot will be useful for this talk.

Spring I/O 2017 - 18 -19 May, Barcelona Software vulnerabilities come in two basic flavors: security bugs and design flaws. Security bugs, such as the popular SQL Injection and Cross-site Scripting vulnerabilities, are errors in coding and because all of them follow the same specific patterns, they can be detected easily by automated tools, even reporting the file and line where the security bug has been found making it simple for software developers to resolve them. However, half of the software related security issues can not be detected by tools. They are design flaws embedded in software and only a person who is familiar with the scope of the web application can identify such vulnerabilities. Until now, they had to be detected manually through pentesting, often resulting in the wholesale redesign of the application architecture. This represents a huge problem for any business or organization, not only due to the economic cost, but more importantly because of the impact on time to market of applications. So, what can we do to solve this problem? This talk presents a solution to protect applications against design flaws and verify them automatically with application security architecture and testing tools working together for the first time. Following a practical approach this talk presents practical examples using Spring reference applications (PetClinic) based on Spring MVC and Spring REST and using well known pentesting tools such as Burp.

Spring I/O 2017 - 18 -19 May, Barcelona One of the most important components in a microservice landscape is the discovery service. During the last few years a large number of alternatives for service discovery have evolved, specifically in the area of container infrastructures. This presentation will, based on my experiences, go through some of the alternatives. The presentation will cover discovery service components in Netflix OSS, Docker Swarm, Amazon ECS and Google Kubernetes. We will also cover how to use Spring Cloud to write microservices that are independent of the selected discovery service, i.e. that can be used with any of the alternatives without requiring modifications of the code.

Spring I/O 2017 - 18 -19 May, Barcelona For many companies, the data they collect and the dataset they build is their most valuable asset. As these datasets grow it becomes increasingly important that these organizations analyze and find meaning in their data, and typically they’ll reach for well-known tools like Hadoop. However, over the past few years a new generation of data analysis tools have become available... most notably Apache Spark. Spark is a cluster-computing framework that allows users to perform calculations against resilient in-memory datasets, distributed across multiple machines, using a functional programming interface. It has won world records for quickly processing large data sets and is currently one of the Apache Foundation’s most active projects. Spark supports a variety of technologies that can be used as its persistence mechanism; one of the most interesting is Apache Cassandra. Cassandra is a linearly scalable, fault tolerant, decentralized datastore that is useful if you need highly available and scalable storage. It is used heavily by some of the largest firms in tech, like Apple, Facebook, and Netflix. These two technologies are complicated, but integrate well and provide such a level of utility that whole companies have formed around these two technologies offering consultancy and development services. In this talk we’ll learn how Spark and Cassandra can be leveraged within your Spring Application, and how to get started with the Spring XD and Data integrations. We’ll talk about Spark and Cassandra from a high level and walk through code examples showing what it’s like to programmatically work with them. We’ll discuss some of the pitfalls you will run into when working with these technologies - like modeling your data appropriately to ensure even distribution in Cassandra and general packaging woes with Spark - and ways to avoid them. Finally, we’ll explore how we at ThirdChannel are using these technologies in the real world.

Spring I/O 2017 - 18 -19 May, Barcelona Slides: https://www.slideshare.net/fbenz/introducing-spring-auto-rest-docs This talk introduces Spring Auto REST Docs, an extension to Spring REST Docs that helps you write less and get more. We have been using and evolving our Spring REST Docs extension for over 1.5 years and recently open sourced it: https://github.com/ScaCap/spring-auto-restdocs Spring Auto REST Docs uses tests, introspection and Javadoc to automatically document request and response parameters. We will look at how much work this saved and how it increased the quality of our documentation. Sprint Auto REST Docs proposes a tight coupling of code and documentation. This way we make it easy to add documentation in the first place, and to keep it up to date as your platform evolves. During the presentation, we give instructions on how to use the extension and discuss pros and cons of the proposed approach. We will present our own system as a real-life implementation and highlight the benefits of reusing tests, bean validation and Javadoc together with the freedom of AsciiDoc to generate documentation. For further reading: https://dzone.com/articles/introducing-spring-auto-rest-docs

Spring I/O 2017 - 18 -19 May, Barcelona Slides: https://speakerdeck.com/sdeleuze/functional-web-applications-with-spring-and-kotlin In this brand new talk, I will show how you can leverage Kotlin and Spring Framework 5 to build functional web applications efficiently. I will describe gradually how you can transform your Spring Boot 1.0 Java project into a Spring Boot 2.0 Kotlin project running on top of the new WebFlux functional web framework: - Step 1: Use Kotlin instead of Java 8 - Step 2: Upgrade to Spring Framework 5 and Spring Boot 2.0 - Step 3: Switch from Spring MVC to WebFlux and Reactive APIs - Step 4: Use WebFlux functional API This talk will detail the upcoming official Kotlin support introduced in Spring Framework 5 [1], and will also demonstrate a real Spring + Kotlin functional web application [2] that I built for the last 6 months for MiXiT conference. [1] https://spring.io/blog/2017/01/04/introducing-kotlin-support-in-spring-framework-5-0 [2] https://github.com/mixitconf/mixit

Spring I/O 2017 - 18 -19 May, Barcelona Links: https://github.com/rburgst/rancherci-presentation https://github.com/rburgst/rancherci-seedjob https://github.com/rburgst/rancherci-demoapp Rolling your own CI system is not easy. Choosing the right solutions is becoming more and more difficult with the advent of new solutions and technologies such as Gitlab CI, CodeShip, Drone.io, travis, ... However, when you have specific needs there are few solutions that can compare with the flexibility of jenkins. Setting up, configuring and managing a jenkins instance can be a laborious job, especially when you are supporting multiple teams which are using different development environments (Java, Node.js, go, ...). Oftentimes it takes days of hand tuning the system per project and keeping up with updates is a job of its own. In this session we will show how to set up a rancher cluster, run jenkins with jenkins swarm on a number of hosts, all build jobs are configured using code (jenkinsfile) so that every change is accounted for in the git history. Due to the use of dockerized build containers it becomes straightforward to support every possible build environment. As a demo we will use a spring based web application which will be built, tested, dockerized and deployed into a staging environment. Time permitting more in-depth topics such as LDAP authentication, SSH key exchange, automatic DNS updates will be addressed. To get the most out of this session a solid understanding of docker and docker-compose is recommended.

Spring I/O 2017 - 18 -19 May, Barcelona One of Spring Boot's most powerful features is its auto-configuration. This magic is key to the convention-over-configuration approach that has brought a huge boost in productivity to Java developers. But is it really magic? We don't think so. In this session we'll take a look under the covers of Spring Boot. You'll learn about auto-configuration and the conditional configuration model that powers it, helping you to be even more productive when writing Spring Boot applications.

Spring I/O 2017 - 18 -19 May, Barcelona Slides: http://presos.dsyer.com/decks/road-to-serverless.html GitHub repo: https://github.com/dsyer/spring-cloud-function Spring Cloud Function provides a new programming model for Spring Boot applications, abstracting away all of the transport details and infrastructure, allowing the developer to keep all the familiar tools and processes, and focus firmly on business logic. Join this presentation to learn about the features of this new project, and why it is going to change the way that you build applications.

Spring I/O 2017 - 18 -19 May, Barcelona Slides: https://docs.google.com/presentation/d/1CRjAKdQEvVNi9JzuudEKlnncJffKi5k8Lw0J335IYMk/edit?usp=sharing The bigger a monolithic application, the larger the dependency set. Adding or changing dependencies becomes a tricky task. Similarly, the complexity is in a number of beans and their dependencies in components container. In this talk, we’ll discuss a way to simplify things by splitting component containers into smaller ones. We’ll see how to split a monolithic ApplicationContext into a number of sub-contexts, how to isolate sub-context internal beans, clear their APIs and avoid non-trivial dependencies. Each sub-context can have its own classpath, which tackles the dependency hell problem. After being divided, a monolithic system becomes easier to split into a set of micro-services or processes. From the talk, attendees will learn several practical tips and tricks on how to split component containers into smaller ones

Spring I/O 2017 - 18 -19 May, Barcelona GitHub repo: https://github.com/neilstevenson/springIO2017 The bigger a monolithic application, the larger the dependency set. Adding or changing dependencies becomes a tricky task. Similarly, the complexity is in a number of beans and their dependencies in components container. In this talk, we’ll discuss a way to simplify things by splitting component containers into smaller ones. We’ll see how to split a monolithic ApplicationContext into a number of sub-contexts, how to isolate sub-context internal beans, clear their APIs and avoid non-trivial dependencies. Each sub-context can have its own classpath, which tackles the dependency hell problem. After being divided, a monolithic system becomes easier to split into a set of micro-services or processes. From the talk, attendees will learn several practical tips and tricks on how to split component containers into smaller ones

Spring I/O 2017 - 18 -19 May, Barcelona Ever wonder how to test a hard problem like caching or write an integration test without making an external API call? Or come across a situation where testing something was so hard that it never got tested? A lot of developers today find themselves in situations where they are unsure of how to write light-weight unit tests. In our presentation, we will talk about how to do Test-driven development for a Spring Boot application and how some of the latest Spring Boot annotations and utilities make that easy. We will deep dive into some tricky real world testing scenarios that have baffled us in the past such as: Database queries Caching Configuration files Form validations Message brokers

Spring I/O 2017 - 18 -19 May, Barcelona Slides: https://speakerdeck.com/dfernandez/o-2017-getting-thymeleaf-ready-for-spring-5-and-reactive GitHub repo: https://github.com/danielfernandez/reactive-matchday Spring 5 is here and it brings a lot of awesomeness — but the star of the show is no doubt the new reactive web framework. Thymeleaf has been the server-side template engine of choice for a lot Spring users for a while now, so once the new Spring reactive infrastructure was sketched some time ago, we took up the challenge of adapting Thymeleaf to the needs of the new framework. From adjusting code to the new APIs –that was easy– to actually making the engine respond to back-pressure requests from consumers –that definitely wasn't–, Thymeleaf had to undergo a good amount of refactoring and rethinking just before the release of Thymeleaf 3.0 last year. The result was a Java server-side template engine able to be as friendly to a reactive application environment as one would need: from normal, good-old templating operation to turning Thymeleaf into an on-the-fly generator of HTML for reactive streams/publishers of data. This talk will offer a quite brief introduction to Thymeleaf and its features for those new to the technology, and then explain the challenges posed by the integration of Thymeleaf with Spring's reactive web framework and the approach of the project to the reactive world in general.

Spring I/O 2017 - 18 -19 May, Barcelona Logging plays an important role on a distributed system. If done right, it helps you when you need it the most: troubleshooting problems in production. We are migrating our current project to Pivotal Cloud Foundry using Spring Boot. We developed a small Spring Boot Starter that can be used by every Spring Boot application to do the logging according to the needs of our system. In this way, the teams can concentrate on developing the business logic of the application. Our Spring Boot starter takes care of automatically logging important logging metadata like trackingId, service name, etc. In this presentation I would like to show you how we tackle the problem of logging in distributed systems by developing a simple but powerful Spring Boot Starter.

Spring I/O 2017 - 18 -19 May, Barcelona GitHub repo: https://github.com/christophstrobl/spring-data-reactive-demo Almost 6 years after its first public release the Spring Data Release train approaches a major version bump of its core modules. In this session we'll revisit key concepts of Spring Data with a strong focus on the Java8 baseline upgrade, lazy component initialization and reactive data access. Code samples outline general strategies as well as store specifics like infinite streams with MongoDB.

Spring I/O 2017 - 18 -19 May, Barcelona In the process of migrating our architecture to microservices we suffered from a lack of alignment across the different applications we have. This brought several painful effects to our organisation, like missing heterogeneous procedures, problems in managing services at scale and a lot of duplicated work across development teams. Almost one year ago we started to develop a common internal framework based on Spring Boot to tackle problems at different levels. We began with monitoring, logging and metrics and we quickly added several other features. One of the main benefits we achieved was to streamline and improve consistency in the way we deploy and support our services from an ops perspective. In this talk we describe the journey that brings us to what we have at the moment: a project inherited from more than 40 different microservices that provide a lot of common features and a clean space where our new contribution model can take place.

Spring I/O 2017 - 18 -19 May, Barcelona How to design and develop internal tools ecosystems, so called commons? You find these in almost every company. Not so obvious task though if you need such ecosystem to stay powerful and easy to use despite constant changes in requirements. We'll dive into structuring the ecosystem, cover API design, handling of dependencies, deciding on features and much more. All this coming from our experience (and mistakes) of building a Spring-based platform and libraries for the microservice infrastructure at Allegro. I hope to leave you with practical knowledge essential for building successful tools – both for growing internal commons and for creating useful open-source libraries in general.

Spring I/O 2017 - 18 -19 May, Barcelona Slides: https://www.slideshare.net/AndreasFalk2/manage-distributed-configuration-and-secrets-with-spring-cloud-and-vault-spring-io-2017 Running multiple instances of microservices as docker images or in the cloud is widely adopted these days. But what about your configuration and secrets? Do you spread all values using application local property files? Do you still store secrets in clear text? In case you are encrypting passwords where do you store the key to decrypt these? Do you already rotate database credentials regularly? In this session you will learn how to externalize your configuration using spring cloud config and store your secrets safely using the recently released spring cloud vault config project. First I will give you a short demo on how to externalize all your application configuration values to a git repository. Then after a general introduction into vault you will see how spring cloud vault config facilitates the integration of vault into your application. After this session you hopefully will be well prepared to start using externalized configuration and to stop ever storing secrets again in an unsafe way.

Spring I/O 2017 - 18 -19 May, Barcelona Link: https://codelabs.developers.google.com/codelabs/cloud-app-engine-springboot/#0 See how we take a standard Spring Boot application, run it on Google Cloud Platform. We will demonstrate how your app will benefit from seamless scalability, and how to use our integrated tooling for testing and diagnostics to gain insights into what's going on with your application in production. In this talk, we go through this flow by deploying the application to the cloud via our build tooling, using two approaches: Google App Engine flexible and Kubernetes.

Spring I/O 2017 - 18 -19 May, Barcelona Slides: https://speakerdeck.com/vpavic/from-zero-to-open-source-hero-contributing-to-spring-projects-1 With any kind of activity, starting out is often the hardest part, and contributing to open-source project is no exception to this. Join this talk by a regular contributor to Spring projects to find out how to kick-start your contributions! This session is a story about author's journey as a contributor to open-source community and Spring projects in particular, a journey the saw him become a committer to Spring Session less than 14 months after authoring his first pull request. The session will present a deep dive into workflow behind a typical pull request to Spring project, stressing the importance of topics such as managing forks, updating pull requests, writing tests, code consistency, and offer many tips & tricks that should help you make your contributions a successful experience.