Description

This course brings together all the important topics related to modern distributed applications and systems in one place. Explore the common challenges that appear while designing and implementing large-scale distributed systems, and how big-tech companies solve those problems. Throughout the course, we are going to build a distributed URL shortening service.

A significant percentage of large-scale enterprises experience performance issues with their business-critical applications. Most of the production systems have been built on top of legacy, monolith technologies. The recent popularity of micro-services will not fulfill its promise of decoupled, scalable, and fault-tolerant systems, unless 'done right'. While entering the world of micro-services, engineers start building distributed applications, where robust remote procedure calls and cluster coordination are a must. You will look at various technologies, algorithms, and design patterns here. Some of them are Service Registry and Discovery, Service Mesh, Apache Cassandra ETCD (coordinator managing Kubernetes clusters), Apache Kafka, Idempotent service design, retry logic, Sharding, and Consistent Hashing, Client-side Load Balancing, Distributed Tracing, Canary Deployment, Sidecar Pattern, Circuit Breaker, and many more. Finally, you will also see the principles of various distributed systems designs; for example, master-less versus with leaders, poll-based versus push-based, immediate versus eventual consistency. After completing the course, learning new distributed database technology would be easier, because you will know the commonly reused techniques, including their pros and cons. All the resource files are available on the GitHub repository at https://github.com/PacktPublishing/Building-Modern-Distributed-Systems-with-Java

What You Will Learn

Look at the concepts of distributed systems
Understand synchronous and asynchronous communication patterns
Study service meshes and Idempotent service design
Differentiate between traditional RDBMS systems and NoSQL
Learn deployment requirements for strongly consistent distributed systems
Build distributed URL-shortening services like Tiny-URL

Audience

This course is designed for Java developers and architects who wish to broaden their knowledge of distributed computing, NoSQL databases, efficient RPC calls, messaging middleware, and cluster coordination. It is also recommended for anyone working in modern IT landscapes. The course may be a good recap for people preparing for systems design interviews.

You will need proficiency in Java programming language, and an open mind to discover the challenges of distributed computing. Beginner-level knowledge in the Spring Boot framework will help you get along with the course easily.

Approach

The course is short yet complete with content delivered with a very practical approach. There are a lot of code examples and applied best practices to follow along at the end of every section. The author will cover Service Registry and Discovery in detail so that you will know how to implement your own framework on top of ETCD. Throughout the course, you will build a distributed URL shortening service.

Key Features

Design and implement globally distributed, scalable, fault-tolerant, and resilience applications * Understanding of common algorithms and techniques used in the majority of NoSQL databases and streaming platforms * In-depth knowledge of Apache Cassandra, Apache Kafka, and ETCD

Github Repo

https://github.com/PacktPublishing/Building-Modern-Distributed-Systems-with-Java

About the Author

Lukasz Antoniak

Lukasz Antoniak is an IT architect who designed and implemented robust back-end systems. After falling in love with Apache Cassandra, his focus shifted toward big data technologies, microservice architecture, NoSQL databases, and distributed message brokers. He is contributing as a committer to various open-source projects, including Hibernate ORM and Apache Bahir (extensions to Apache Spark). He worked for a few years on the distributed core banking platform for a major European bank. He has also worked previously for big-tech companies such as Oracle, IBM, HP, and TIBCO. In his spare time, he enjoys sailing and photography.

Course Outline

1. Concepts of Distributed Systems

1. Evolution of Computer Systems' Architecture

This video talks about the evolution of computer systems' architecture.

2. Challenges of Distributed Compounding

This video demonstrates the challenges of Distributed Compounding.

3. Use-Case of Course Application

This video demonstrates the use-case of course application.

4. Practice 1

This is the first practice video that focuses on the environment setup for Tiny-URL project.

2. Remote Procedure Call

1. The Need of Communication

This video explains the need of communication.

2. Message Transport and Format

This video explains the Message transport and format.

3. Synchronous and Asynchronous Communication Patterns

This video demonstrates the synchronous and asynchronous communication patterns.

4. Traditional Load Balancers

This video explains the traditional load balancers.

5. Service Registry and Discovery

This video explains about the Service Registry and Discovery.

6. Service Meshes

This video demonstrates the Service Meshes.

7. Idempotent Service Design

This video talks about Idempotent service design.

8. Practice 2

This is the second practice video that focuses on the resilient RPC (Remote Procedure Call) configuration and service discovery technology.

3. Distributed Databases

1. Traditional RDBMS Systems Versus NoSQL

This video differentiates between the traditional RDBMS systems and NoSQL.

2. Data Sharding and Consistent Hashing

This video talks about Data Sharding and Consistent Hashing.

3. CAP theorem

This video explains the CAP theorem.

4. Short Introduction to Apache Cassandra

This video provides a short Introduction to Apache Cassandra.

5. Practice 3

This is the third practice video that focuses on the distributed database and usage of Apache Cassandra in Tiny-URL project.

4. Cluster Coordination

1. The Need of Cluster-Wide Coordination

This video demonstrates the need of cluster-wide coordination.

2. RAFT Consensus Algorithm

This video explains the RAFT consensus algorithm.

3. Short Introduction to ETCD

This video provides a short introduction to ETCD.

4. Implementation of Distributed Mutex

This video provides an implementation of distributed mutex.

5. Leader Election Design Pattern

This video explains the leader election design pattern.

6. Deployment Requirements for Strongly Consistent Distributed Systems

This video talks about the deployment requirements for strongly consistent distributed systems.

7. ACID Properties in Distributed System

This video demonstrates the ACID properties in distributed system.

8. Practice 4

This is the fourth practice video that shows how to introduce cluster coordination into Tiny-URL application.

5. Distributed Messaging Systems

1. Asynchronous Communication Pattern and Message-Oriented Middleware

This video talks about the asynchronous communication pattern and message-oriented middleware.

2. Short Introduction to Apache Kafka

This video provides a short introduction to Apache Kafka.

3. Apache Kafka as a Distributed System

This video explains how Apache Kafka acts as a distributed system.

4. Event-Driven Architecture

This video talks about Event-Driven architecture.

5. Practice 5

This is the fifth practice video that focuses on the usage of distributed messaging systems.

Course Images

Building Modern Distributed Systems with Java

By Packt

Booking options

Highlights