[NEW] Master Spring Boot Microservice & Angular K8s CICD AWS

Explore monolithic applications built as a single large code base with client, server, and database layers, where one database serves the server and client interactions, highlighting limited modularity.

A monolithic code base grows and becomes hard to manage, upgrade, or scale without affecting the entire application. A single bug can crash the whole system, hindering continuous deployments.

Explore how microservices replace monoliths by breaking applications into independent, deployable modules that serve a single capability and communicate via RESTful services or messaging.

Microservice architecture keeps services independent, enabling independent deployment, easy testing, fault isolation, and the freedom to choose different technologies, interacting via REST or messaging.

Explore a high-level microservices architecture where an angular UI calls RESTful services, each with its own database, while an API gateway routes requests and Eureka enables service discovery.

Explore why we use Eureka as a server-side registry and discovery service for microservices, handling dynamic IPs, health status, and load balancing to enable fault-tolerant communication.

Set up a spring boot project as a standalone Eureka server by adding the Eureka Server dependency and enabling Eureka Server. Configure application.yaml with port 8761 and standalone mode.

Learn to build a restaurant listing microservice with Spring Boot by implementing REST endpoints for listing, retrieving by ID, and adding restaurants, using MapStruct DTOs, JPA, MySQL, and Eureka client.

Build user details service to manage user id, username, password, and delivery address, endpoints to add and fetch by id, using Java 11, Spring Boot, MySQL, Lombok, MapStruct, and Eureka.

Configure the order microservice with Spring Boot and Eureka, using MongoDB to store order, restaurant and user details. Save details as a document and enable rest endpoints with inter-service calls.

Explore Angular as a client-side framework using HTML and TypeScript, and see how TypeScript, a Microsoft-designed superset of JavaScript, adds object-oriented features, strong typing, and compile-time checks.

Explore Visual Studio Code as a lightweight, powerful editor for JavaScript and TypeScript, and learn how NodeJS runs and reinterprets code with CLI commands ng new, ng generate, ng serve.

Learn how npm install and package-lock.json lock versions from package.json in angular apps. Understand dependencies vs dev dependencies, tilde and carrot versioning, and nested dependencies across production and development.

Explore how angular's app module defines the root module and bootstraps the app component. Learn how declarations, imports, providers, and bootstrap weave from index.html through main.ts to the root component.

Explore how Angular dependency injection works through services and injectors, including root, module, and component scopes, and how tree-shakable providers with providedIn root optimize app performance.

Design a modular angular front end for a food delivery app featuring restaurant listing, food catalog, and order summary pages; connect to microservices and databases with wiremock.

Set up a front-end for a food delivery app with Node.js, npm, and Angular CLI, then build an Angular UI featuring routing, header, restaurant listing, food catalog, and order summary.

Design an Angular restaurant listing module with routing, a service to call the restaurant listing microservice, and DTO models. Navigate to the food catalog on button click.

Design and implement a food catalog module in Angular, connect to food catalog and restaurant microservices, build shared models, enable id-based routing and checkout to order summary.

Build an Angular order summary module with routing, create order service and components, post save order to backend microservice, calculate totals, show order placed dialog, and navigate to restaurant listing.

Explore how Docker uses containerization to package an application and its dependencies into portable containers for microservices. Learn how Dockerfile builds images and ensures consistent execution across environments.

Create a dockerfile to build a read-only image and run a container, using docker build and docker run to turn a blueprint into a running runtime instance.

Learn how a dockerfile builds a docker image from a base OpenJDK Alpine, configures /opt and port 8089, and runs java -jar app.jar via entrypoint.

Build a docker image from a Dockerfile using docker build, creating a read-only blueprint. Run it with docker run to start a container and push or pull on Docker Hub.

Launch a container as an isolated runnable instance of an image; manage it with Docker CLI or APIs, and Docker networking lets it access databases while staying isolated.

Explore how Docker Hub serves as the cloud-based default registry to store, pull, and push Docker images, enabling team collaboration and container deployment.

Learn how to dockerize applications to eliminate environment discrepancies by packaging dependencies and exact versions into a single image, then deploying via Docker Hub with CI/CD for production rollout.

Learn to dockerize a multi-service application by adding Dockerfiles to backend microservices and an Angular frontend, build and push images to Docker Hub, and prepare Kubernetes deployments with port mappings.

Learn how to use Spring Boot profiling to manage environment-specific configurations, activate dev and local profiles, and deploy containerized microservices to Kubernetes with Eureka service discovery.

Learn why AWS cloud deployment supports full stack apps with EC2 and ECS, Kubernetes (kubectl), load balancers, and databases like RDS and Mongo Atlas, plus free tier and pay-as-you-go pricing.

Install Chocolaty, a Windows package manager, to install and manage prerequisites for connecting to AWS, ECS clusters, and Kubernetes commands in the cloud deployment workflow.

Learn how to set up an AWS EKS cluster using the AWS CLI, eksctl, and kubectl, including configuring IAM permissions, creating a London-based cluster, and generating kubeconfig for access.

Install and configure the AWS CLI, eksctl, and kubectl to create an AWS EKS cluster, understand the AWS managed control plane, and deploy workloads with kubectl.

Configure a separate, persistent cloud database with aws rds rather than a local db. aws's fully managed relational database service provisions, backs up, and scales databases like mysql.

Create a MySQL RDS in eu west 2 using standard create, enable public access, and set admin credentials; then migrate data from local to RDS and verify connectivity.

Deploy, manage, and scale the MongoDB NoSQL database with MongoDB Atlas, a fully managed cloud service. Separate infrastructure concerns by letting Atlas handle backups and scaling.

Set up a free MongoDB Atlas cluster by creating a project, configuring a cluster, whitelisting 0.0.0.0/0, then connect with Compass for AWS deployments.

Discover how Kubernetes automates deployment, scaling, and management of containerized microservices and front-end apps, using Docker containers for reliable orchestration across cloud platforms.

Explore how Kubernetes deploys containers into pods, scales automatically, balances load, and self-heals containerized applications for high availability and fault tolerance.

Understand how Kubernetes uses worker nodes and pods as core deployment units, why pods are typically single-container and disposable, and how services avoid hard IPs for stable communication.

Explain three service types—cluster IP, node port, and load balancer—and how they expose internal and external access for microservices such as food catalog and restaurant listing.

Explore how config maps decouple application configurations from code, enabling easy updates to database properties and external service settings without rebuilding container images in Kubernetes.

Learn how secrets store base64 encoded key-value data to protect passwords, API keys, tokens, and certificates. Compare secrets with config maps to supply values to containers.

Compare secrets and configmaps by data sensitivity and update behavior. Secrets store sensitive data with base64 encoding and immutability, while configmaps hold non-sensitive data as text with flexible updates.

Volumes provide persistent storage for stateful services in Kubernetes, keeping data safe beyond pod lifecycles. Avoid deploying databases as pods; use external cloud-managed db services for data integrity.

Discover replica sets in Kubernetes, why at least 2–3 replicas ensure high availability and fault tolerance, and how deployments manage pod replicas via a manifest.

deployments in kubernetes act as the blueprint to run and manage your application, ensuring the desired number of pods and replicas stay up and are scaled automatically.

Explore how stateful sets in Kubernetes manage stateful applications like databases by giving each pod persistent storage and preserving data across restarts, unlike deployments for stateless apps.

Explore how Kubernetes manifest files serve as blueprints to create and manage deployments, pods, services, and other resources, enabling infrastructure as code, automation, and declarative configurations.

Learn to create Kubernetes manifest files for deployment, service, config map, and secrets, including a stateful set for Eureka, with pod templates, labels, and environment wiring to RDS and MongoDB.

Expose front-end via external IP, or ingress and load balancer patterns; keep back-end as cluster IP. Monitor service registrations with Eureka and test pods via port forwarding inside Kubernetes.