For long, the conventional approach to build software systems has been the so-called monolithic architectural style, in which all logic (e.g. user interface, back-end, connections to database etc.) is derived as a single deployable software artifact. However, the fact that everything is assembled to a single file should not create the illusion that the development of the whole business logic is as easy as integrating all to a single file. Instead, the complexity of a single repository that increases constantly over time makes the maintenance of the code challenging, not to mention the painful task of integrating new features. The long experience of dealing with monolithic software architectures has raised some drawbacks that constitute a major hindering factor for further adoption:
- Tight coupling of software components, since everything is assembled to a single artifact.
- Less reusability
- Large code base which makes it tough for developers and QA engineers to understand the code and the business logic that it implements
- Less scalable
- Increased startup and shutdown times (which intuitively increases with the complexity of the code)
- Locked into increasingly obsolete technology stack, due to inability to adapt the huge code to a new upgrade
To drastically overcome drawbacks such above, the microservice architectural style has been proposed, which in short encourages to develop a single application as a suite of small services, each running in its own process and communicating with lightweight mechanisms, often an HTTP resource API. These services are built around business capabilities and are independently deployable by fully automated deployment machinery. There is a bare minimum of centralized management of these services, which may be written in different programming languages and use different data storage technologies. This simply means that microservices is a refined version of distributed systems, but with new strong capabilities that give unique capabilities. As it becomes understood, microservices (as a highly distributed architecture) come with specialized design patterns that are optimized to deal with intense interservice synchronous and asynchronous communication, with distributed data management, with service failures and recovery in random fashion and many more. This clearly implies that Microservices are mostly based on APIs.
Spring Boot has been aligned with microservices software design approach and provides a plenty of solutions out of the box that are ready for cloud. For example, it is optimized to quickly standing up robust REST services with a minimum of fuss and also offers Actuator module for exposing ready-to-use health endpoints, creation of custom health checks etc. Getting all of this out of the box is a good start, but not enough. There is much more to be done before a service goes to production. On top of Spring boot, Spring Cloud integrates all key libraries and fundamental microservice design patterns, e.g.service discovery, load balancing, Gateway, rest clients, token authentication, caching, messaging systems, circuit breakers and so on. Although Spring integrates all these yet independent modules, its great power is that it does in a seamless manner, thus allowing the developer to focus on the business logic eliminating the need to write boilerplate code.
- This specific Code.Learn program lasts 2 weeks (2 Fridays & 2 Saturdays) and consists of 24 hours of lectures and hands-on exercise on real case studies and projects.
Key Objectives – Curriculum
The purpose of this Unit is to provide a solid and to the point introduction of Microservice design and development with Spring boot framework. It specifically eliminates all unnecessary theory, trying to reduce the learning curve and maximize the learning outcomes. The participants will begin by learning how to build RESTful web services with Spring Boot and Spring Data and they will realize that a significant portion of microservice development is not any different from regular REST service development. The course continuous with Spring Cloud framework that integrates foundational microservice components in a smooth way to ease engineers to implement complex architectures relatively easy. The participants will realize that using this framework, functionalities like dynamic scaling, load balancing, dispatching, centralized configuration and resiliency can be easily implemented.
In particular, the core perspectives of this program will be to present, explore and adequately cover with extended real-life business case studies & industry scenarios the following aspects:
- Introduction to Microservices
- Definition of Microservices
- Comparison of microservices against monolith approach (pros & cons)
- Brief overview of key architectural components: API Gateway, Service Discovery, Centralized Configuration Server, Load Balancer
- Spring Boot & Restful APIs
- Why Spring Boot is so popular for this scope
- Restful APIs with Spring Boot
- Spring Boot new project initialization
- Controller classes, DAO classes
- HTTP status code control in response messages
- Configuration Server Microservice
- Centralized configuration server as part of a microservice architecture solution
- Configuration Server sample implementation and setup with Spring Boot and Spring Cloud
- Connect 3rd party microservices with configuration Server
- Client-side Load Balancing of Microservice Instances
- Invoke one microservice from another microservice
- Introduction to Ribbon
- Enable load balancing mechanism to microservices with Ribbon and Feign
- Naming server & API Gateway Microservices
- Naming Server microservice sample implementation and setup with Spring Boot and Spring Cloud
- Connect 3rd party microservices with Naming Server: Validate service discovery and service registration
- API Gateway microservice sample implementation and setup with Spring Boot and Spring Cloud
- Connect 3rd party microservices with API Gateway
- End-to-end Microservice functionality and overview
- Hands on practice with all microservices up and running
- Advanced Restful APIs with Spring Boot (generic exception handling, validations, connection with Java Persistence API)
- Health monitoring of microservices with Spring Actuator
The lessons can be carried out:
- Inside a physical classroom with an instructor,
- In an online environment as a virtual classroom, with live connection with the instructor through video conferencing; or lastly,
- A combination of both physical and online.
The method of teaching will depend on the current conditions, and also on the participants’ preferences.
Regarding online, the instructor provides the taught material through screen sharing, live broadcast, or by working on the cloud where attendees can see and interact with everything in real-time. Attendees themselves can seamlessly and actively participate and ask questions, as they would in a physical classroom. Additionally, they can collaborate in team projects and deliver assignments and hands-on projects that the instructor can see and provide feedback easily and without delays.
Computer scientists, software engineers and developers are welcome to participate to this code.learn program and unlock the full potentiality of the topics taught by upskilling their future career.
Participants are expected to have experience with Git and Java. Experience with Spring framework is welcome but not mandatory.