Implementing Software Architecture of a Large-Scale System

Implementing Software Architecture of a Large-Scale System, available at $84.99, has an average rating of 4.67, with 83 lectures, based on 359 reviews, and has 6097 subscribers.

You will learn about Understand through code, the architectural challenges of developing large-scale systems – Scalability, Reliability, Deployment, Observability Code implementation of various tools and technologies used for making large-scale systems – Redis, RabbitMQ, Netflix, Fluentd, Elasticsearch, Kubernetes & more Downloadable code along with configuration, scripts and instructions to run a mini system on your laptop and on a cloud environment A practical demonstration of how systems are scaled and operated on both On-Premises environment and in Cloud environments This course is ideal for individuals who are Developers and Architects who want to learn the fine details of architecting large-scale systems It is particularly useful for Developers and Architects who want to learn the fine details of architecting large-scale systems.

Enroll now: Implementing Software Architecture of a Large-Scale System

Summary

Title: Implementing Software Architecture of a Large-Scale System

Price: $84.99

Average Rating: 4.67

Number of Lectures: 83

Number of Published Lectures: 83

Number of Curriculum Items: 83

Number of Published Curriculum Objects: 83

Original Price: $39.99

Quality Status: approved

Status: Live

What You Will Learn

Understand through code, the architectural challenges of developing large-scale systems – Scalability, Reliability, Deployment, Observability

Code implementation of various tools and technologies used for making large-scale systems – Redis, RabbitMQ, Netflix, Fluentd, Elasticsearch, Kubernetes & more

Downloadable code along with configuration, scripts and instructions to run a mini system on your laptop and on a cloud environment

A practical demonstration of how systems are scaled and operated on both On-Premises environment and in Cloud environments

Who Should Attend

Developers and Architects who want to learn the fine details of architecting large-scale systems

Target Audiences

Developers and Architects who want to learn the fine details of architecting large-scale systems

The best way to learn software development is to write code. The best way to learn software architecture is to build and run a system. This is exactly what you are going to do as part of this course!

This course is the next in the series of Developer to Architect courses. The previous course ‘Software Architecture & Technology of Large-Scale Systems’ was focused on the concepts and principles of software architecture that govern modern large-scale systems.

This course ‘Hands-On Implementation of Large-Scale Software Architecture’, is focused on implementing those software and solution architecture principles in a mock large-scale system (mini system or simply minisys) by using open source technologies.

It starts with a downloadable code base of a mini system. We evolve this mini system into a full-fledged large-scale system implementation as we move along with the course. Our goal is to learn the typical architectural challenges that are faced by any large-scale system and solve these challenges using modern tools, technologies, and methods.

You can learn about these challenges and their solutions by actually working on a live system. For the same, you can download a mini system code-base provided by NewTechWays on Bitbucket or Github. You can follow the instructions to download, build and run this codebase. Although the instructions and code automation is platform-agnostic, this course will make use of Google Cloud Platform using a Linux machine as our test environment for building and running the system. Later we will put our system in a Production kind of environment using Kubernetes on Google Cloud Platform.   

As we move along with this course we will cover the following architectural challenges and use the following technologies as their solutions:

3 Tier Application

Webapp – Python Django

RESTful Service – Java Spring Boot

Database – PostgreSQL & Cassandra

SPA – ReactJS

Containerization of System

Docker Containers

Docker Compose

Request Routing in Microservices

Discovery – Netflix Eureka

Gateway – Netflix Zuul

Client-Side Load Balancer – Ribbon

Server-Side Load Balancer – Nginx

System Observability

Logging – Elasticsearch, Fluent, Kibana

Tracing – Jaeger

Monitoring & Alerts – Prometheus

Large-scale Data Management

Caching – Redis

Asynchronous Processing – RabbitMQ

Horizontal Data Partitioning – Cassandra

Production Deployment

Cloud Deployment – Kubernetes on GCP

Auto-scaling – Kubernetes

High Availability – Kubernetes

Rolling Upgrades – Kubernetes

Course Curriculum

Chapter 1: Course Overview

Lecture 1: Introduction

Lecture 2: Course Overview

Lecture 3: Course Content Pdf

Chapter 2: Work Environment Setup

Lecture 1: Work environment

Lecture 2: Create Linux workstation VM on cloud

Lecture 3: Build code

Lecture 4: Workstation VM backup

Chapter 3: System Components – Languages & Frameworks

Lecture 1: System components overview

Lecture 2: Running the system on cloud Linux VM

Lecture 3: Web app architecture and technology selection

Lecture 4: Python Django web app code overview

Lecture 5: Services architecture

Lecture 6: Services technology selection

Lecture 7: Java SpringBoot services code overview

Lecture 8: Database technology selection

Lecture 9: Postgres RDBMS schema overview

Lecture 10: Single page app technology selection

Lecture 11: ReactJS SPA architecture

Chapter 4: Docker Containers – Isolating component dependencies and environment

Lecture 1: Why containerize application components?

Lecture 2: System with docker containers

Lecture 3: Dockerize django webapp

Lecture 4: Docker compose for automation

Lecture 5: Dockerize postgres database

Lecture 6: Dockerize java springboot services

Lecture 7: Dockerize reactjs single page app

Lecture 8: Running all dockerized components

Lecture 9: Running system with docker network

Lecture 10: Docker network and volumes

Lecture 11: System review with docker containers

Chapter 5: Microservices – Gateway, Discovery & Load Balancing

Lecture 1: Client routing challenge & Gateway services

Lecture 2: Netfix Zuul gateway service code and configuration

Lecture 3: Running system with Netfliz Zuul gateway service

Lecture 4: Static routing challenge & Discovery services

Lecture 5: Netflix Eureka discovery service code and configuration

Lecture 6: Running system with Netflix Eureka discovery service

Lecture 7: Client based & Server based Load balancing

Lecture 8: Netflix Ribbon load balancer code and configuration

Lecture 9: Running system with Nginx & Ribbon load balancers

Chapter 6: Centralized Logging with Elasticsearch, Fluentd & Kibana (EFK stack)

Lecture 1: System Observability – Logging, Tracing and Monitoring

Lecture 2: Logging challenges in large-scale systems

Lecture 3: Centralized logging architecture

Lecture 4: Incrementing VM capacity

Lecture 5: Configuration of Elasticsearch, Fluentd & Kibana (EFK stack)

Lecture 6: Observing system with Elasticsearch, Fluentd, Kibana stack

Chapter 7: Distributed Tracing with Uber Jaeger

Lecture 1: Tracing challenges in large-scale systems

Lecture 2: Distributed tracing architecture

Lecture 3: Distributed tracing with Uber Jaeger

Lecture 4: Distributed tracing core mechanism

Lecture 5: Uber Jaeger instrumentation code and configuration

Lecture 6: Observing API latency using Jaeger tracing

Chapter 8: Metrics Monitoring with Prometheus

Lecture 1: Metrics for large-scale systems

Lecture 2: Exposing application component metrics for Prometheus

Lecture 3: Prometheus configuration for metrics

Lecture 4: Observing system metrics through Prometheus

Chapter 9: Data Caching with Redis Cache

Lecture 1: Challenges of high request and data volume

Lecture 2: Caching for managing read only load

Lecture 3: Caching technology selection

Lecture 4: Service code changes for Redis cache

Lecture 5: Redis cache configuration

Lecture 6: Running system with Redis cache

Chapter 10: Asynchronous Processing with RabbitMQ

Lecture 1: Managing write only load for Async workflows

Lecture 2: Messaging queue technology selection

Lecture 3: Service code changes for RabbitMQ

Lecture 4: RabbitMQ configuration

Lecture 5: Running system with RabbitMQ

Chapter 11: Horizontal Scalability with Cassandra

Lecture 1: RDBMS Limitations and Data Partitioning

Lecture 2: Distributed database technology selection

Lecture 3: Cassandra schema vs Postgres schema

Lecture 4: Service code changes for Cassandra

Lecture 5: Cassandra configuration

Lecture 6: Running system with highly available Cassandra database cluster

Chapter 12: Deployment with Kubernetes on Google Cloud

Lecture 1: Moving from test deployment to production deployment

Lecture 2: Reasons for Kubernetes and Cloud deployment

Lecture 3: Kubernetes cluster architecture

Lecture 4: Setting up Cloud Container Registry

Lecture 5: Creating Kubernetes Cluster on Google Cloud

Lecture 6: Kubernetes configuration for the system

Lecture 7: Deploying system on Kubernetes

Lecture 8: Exposing system to Internet using External Load Balancers

Lecture 9: High availability with Kubernetes

Lecture 10: Auto-scaling with Kubernetes

Lecture 11: Rolling upgrades with Kubernetes

Lecture 12: Shutting down Kubernetes cluster

Instructors

NewTechWays – Anurag Yadav
Making knowledge available for everyone

Rating Distribution

1 stars: 4 votes

2 stars: 3 votes

3 stars: 19 votes

4 stars: 108 votes

5 stars: 226 votes

Frequently Asked Questions

How long do I have access to the course materials?

You can view and review the lecture materials indefinitely, like an on-demand channel.

Can I take my courses with me wherever I go?

Definitely! If you have an internet connection, courses on Udemy are available on any device at any time. If you don’t have an internet connection, some instructors also let their students download course lectures. That’s up to the instructor though, so make sure you get on their good side!