System Design & Software Architecture: AWS + Microservices

Explore the basics of software architecture and system design, clarify the differences between them, and outline the mindset and roles of software and solutions architects.

Explore core architectural concepts and terminology, including stateless versus stateful design, load balancing, decoupling, and fault tolerance. Examine relational versus non-relational databases, partitioning, and consistency types.

Design, develop, and deploy APIs with HTTP REST API, gRPC, and GraphQL; master asynchronous messaging using AMQP, RabbitMQ, and Apache Kafka, and explore Amazon SQS, SNS, WebSockets, and data streaming.

Explore HTTP 1, HTTP 2, and HTTP 3, highlighting HTTP 2's binary framing, multiplexing, header compression, and server push, and HTTP 3's QUIC-based, low-latency security improvements.

Learn how rest defines a scalable architectural style on http, using resources addressed by urls and json data, manipulated with methods like get and post.

Practice rest features by treating each resource as a unique uri, enforcing a uniform interface with standard http methods and json responses, and enabling stateless, cacheable interactions.

Rest development considerations, including resource identification with nouns in uris, appropriate http methods, stateless design, security, input validation, pagination, filtering, sorting, rate limiting, and thorough api documentation.

Explore gRPC, a high performance open source framework by Google for distributed systems, leveraging HTTP/2, protocol buffers, and code generation for secure, language-agnostic RPC.

Explore gRPC with Node.js by comparing dynamic and static code generation. Load proto files at runtime with proto loader or generate JavaScript or TypeScript code via grpc tools.

Compare Rest and gRPC architectures by exploring similarities: client–server models and HTTP, and differences in data formats (JSON vs protobuf), contracts (Rest lacks a formal interface), and gRPC's high performance.

Practice an end-to-end practical of graphql with apollo server and apollo client, building a graphql server and a react-based client using typedefs, resolvers, queries, and mutations.

Explore AMQP's asynchronous messaging with producers, brokers, and consumers, where the broker queues and routes messages like a post office. Grasp exchanges, queues, and publish-subscribe patterns for scalable distributed systems.

amqp queues store messages until consumption, decoupling producers from consumers for reliability. exchanges route messages to queues via bindings, with persistence, durability, exclusive, and auto delete.

Discover RabbitMQ as a cross-language message broker supporting point-to-point, publish-subscribe, and request-reply patterns, with exchanges routing to queues and idempotent consumers ensuring at-least-once delivery for microservices.

Build a Node.js RabbitMQ practical using the amqp lib to create a producer and consumer, set up a Dockerized server, and assert a durable queue with persistent messages.

Trace order placement through event sourcing: client request becomes a place order command, triggers an order placed event in the event store, and updates projections and read models via handlers.

master data streaming concepts across gRPC, Apache Kafka, RabbitMQ, and AWS Kinesis, and see how message brokers buffer and deliver real-time data between producers and consumers.

Explore AWS Kinesis, a managed streaming service for real-time data collection and processing, including streams, Kinesis Firehose, and analytics, and compare it with Apache Kafka in flexibility and use cases.

Explore Amazon SQS, a fully managed, serverless messaging service for decoupling microservices, with standard and FIFO queues, dead letter queues, message retention, and pay as you go pricing.

Create a standard Amazon SQS queue with the AWS SDK for Node.js, configure visibility timeout, retention, delivery delay, and polling; implement send and receive message in JavaScript.

Explore the Amazon sns publish-subscribe model, topic-based message delivery, and fifo topics for a2a and a2p messaging, delivering notifications, emails, sms, and push via multiple protocols.

Explore popular asynchronous messaging systems, from AMQP with RabbitMQ, Apache Qpid, and ActiveMQ to JMS and MQTT, Kafka, and cloud services, and learn to handle duplicate messaging with idempotent patterns.

Explore how WebSocket offers a full-duplex, persistent, real-time connection between client and server via HTTP handshake and data frames. Apply it to chat, live updates, and online gaming.

Explore architectures from client-server to microservices, including monoliths and domain-driven design, and apply patterns like CQRS, saga, event sourcing in AWS serverless contexts.

Explore common architectural styles as blueprints for system structure, comparing how components interact and communicate across client-server, layered, monolith, service-oriented, microservices, event-driven, and serverless designs to meet project requirements.

explore client-server and n-tier architectures, where thin or thick clients request services from a centralized server over http or tcp, enabling scalable resource management.

Explore how component-based architecture uses reusable, decoupled components with interfaces and dependency injection to promote modularity, encapsulation, scalability, and lifecycle management.

Examine monolithic architecture, where the application and database run as a single unit with a unified code base, ideal for small to medium apps, yet with scalability drawbacks.

Learn how service oriented architecture breaks an application into modular, loosely coupled services that can be independently deployed and scaled across cloud regions, with centralized or multiple databases.

Explore service oriented architecture by detailing components such as the service provider, registry, consumers, and enterprise service bus, plus contracts, interfaces, REST or SOAP interactions.

Microservices architecture uses small, independent services with single responsibilities that communicate via well-defined APIs, each managing its own data store and deploying independently with http/https or grpc for scalability.

Explore domain driven design and its focus on modeling complex business domains. See how bounded contexts, ubiquitous language, and decoupled autonomous domains complement microservices.

Explore microservices communication strategies, including direct http or grpc calls and discovery via a service registry. Understand how an api gateway centralizes routing and authorization, with performance and scalability tradeoffs.

Explore synchronous versus asynchronous service interactions in microservices, using HTTP/REST/gRPC for real-time calls and messaging patterns with RabbitMQ, SQS, Kafka, and PubSub to enable decoupled, scalable, event-driven architectures.

Explore microservices architecture components, focusing on service discovery patterns—client-side and server-side—through a service registry, self-registration, third-party registration, health checks, and API gateway implications.

The load balancer distributes traffic across multiple servers, performs health checks and auto scaling, and offers SSL termination, session persistence, and DDoS protection using AWS elastic load balancer types.

Route client requests through an API gateway as the single entry point, handling authentication, rate limiting, logging, request/response transformation, and aggregation of microservice responses.

Compare api gateway built-in load balancing versus separate load balancers for traffic management and latency. Evaluate impact on scalability, reliability, service discovery, and security features like authentication and rate limiting.

Explore how a service mesh enables secure, reliable service to service communication with traffic management and observability through sidecar proxies, and how a configuration server centralizes runtime settings and secrets.

Define microservices as an architectural style, not identical to containerization, while containerization and orchestration provide isolation, independence, scalability, and resilience for loosely coupled services.

Explore common microservices design patterns, including database per service, service breaker, service discovery, CQRS, event sourcing, saga, aggregator, API gateway, strangler, and backend for frontend.

Learn how the database per service pattern gives each microservice its own database, enabling autonomy and scalable, technology-flexible services, while addressing data consistency and cross-service latency challenges.

Explore how microservices apply the circuit breaker pattern to prevent overloads by stopping requests when failures exceed a threshold, using open, half-open, and closed states for fault isolation and resilience.

Explore the saga pattern for managing distributed transactions in microservices, using choreography and orchestration approaches, with compensation transactions and event-driven workflows demonstrated through an e-commerce example.

The CQRS pattern separates reads and writes to boost performance and scalability, using separate services and a read database or replica to serve fast dashboards while keeping data consistent.

Capture all state changes as immutable events with an event store, replaying them to reconstruct current or past states, while aggregates, commands, and projections drive the event-driven architecture.

Trace CQRS with event sourcing from a create order command through the command side, aggregates, and event store, then update the read replica and respond via the query side.

Master choreography, an event-driven, decentralized pattern with loose coupling and asynchronous actions, and explore the aggregator and backend-for-frontend patterns for a single, composed client response.

Explore authentication, authorization, and access controls, including RBAC and AWS IAM, with JWTs and OAuth/OpenID Connect, plus TLS and KMS-based protection and basic AWS firewall concepts.

Explores single sign-on (SSO) and other authentication types, showing how JWT enables stateless authentication for accessing multiple applications with one credential, via protocols like SAML, OAuth, and OpenID Connect.

Explore authorization types, focusing on role based access control, attribute based access control, and discretionary access control, with RBAC enabling permissions via roles and central policy management.

Master AWS identity and access management by configuring users, groups, roles, and granular policies with least privilege and MFA for services like S3, EC2, and Lambda.

Explore identity-based and resource-based IAM policies, with actions and policy types (AWS managed, customer managed, inline), including read-only S3 access and cross-account capabilities.

Explore AWS IAM policies, including trust policies that allow role assumption for services like EC2, plus permission boundaries and service control policies for organization-wide access control.

Explain the AWS shared responsibility model by contrasting security of the cloud, which AWS maintains, with security in the cloud, managed through VPCs, subnets, security groups, NACLs, and credentials.

Learn to create Amazon Cognito user pools for sign in and sign up in web apps, configure attributes and callbacks, manage sessions, and customize branding and identity providers.

Use identity pools to grant temporary AWS access for Cognito user pool and federated or guest users, with roles authorizing actions on S3 and EC2.

Explore OAuth 2.0 architecture with client, authorization server, resource owner, and resource server, and compare authorization code flow with the implicit grant, including token exchange and security implications.

Master OpenID Connect as the identity layer on top of OAuth, using identity tokens (JWT) and user info endpoints to authenticate and manage profile or email data via scopes.

Evaluate local authentication versus identity providers (IdPs) for secure, scalable access. Leverage OAuth or OpenID Connect to simplify user experience, reduce development effort, and ensure compliance.

Explore how the tls 1.3 handshake simplifies key exchange, detailing client hello, version and cipher suite selection, client and server randoms, master secret, and finished message exchange aided by certificates.

Explore secure tunneling methods such as vpn, ssh, and ipsec, detailing encapsulation, encryption, authentication, and the creation of secure channels to protect data across networks.

Explore security in transit across AWS services by enabling HTTPS for VPC traffic, CloudFront delivery, Elastic Load Balancing, and S3 transfers, including bucket policy conditions for secure transport.

Store and manage secrets securely with AWS Secrets Manager, enabling automatic rotation, fine-grained access control, and encryption with KMS for credentials and connection strings.

Learn how AWS security groups act as stateful firewalls for EC2 and RDS with inbound and outbound rules, following least-privilege. Compare them to NACLs, which are stateless subnet-level controls.

Examine how NACLs in subnets govern inbound and outbound traffic, and how security groups provide stateful, selective access for EC2 instances in AWS.

Explore core security services in aws, including Amazon Cognito, GuardDuty, Detective, Security Hub, Web Application Firewall, Shield, kms, Secrets Manager, and Certificate Manager.

Create an aws account by signing up for a free account, verify your email with the captcha, and provide basic and payment information to access the aws console.

Use the AWS pricing calculator to estimate and optimize costs for services like EC2, compare on-demand and reserved options, and review the 12-month and always free tiers.

Use the AWS pricing calculator to estimate Amazon RDS costs by region, instance type, utilization, multi-AZ versus single-AZ configurations, on-demand pricing, and storage.

Create a Node.js AWS lambda function from scratch with an S3 trigger for object creations to log details to CloudWatch, and attach an IAM role for S3 and CloudWatch access.

Create a public REST API in API gateway to invoke a Lambda function with a GET method on the /customer resource, deployed to a dev stage with an endpoint.

Contrast vertical scaling, upgrading existing server hardware for immediate performance boosts, with horizontal scaling, adding servers for scalable, resilient load distribution, despite downtime and complexity.

Learn how to scale resources by vertical and horizontal approaches, adjusting vcpu, memory, storage, and I/O, and scale only bottleneck components across web, app, and database services.

Harness cloud infrastructure for global scalability, vertical and horizontal scaling, and auto-scaling of EC2 instances, supported by AWS regional coverage to ensure reliability, performance, and cost efficiency.

Explore AWS application auto scaling as a general scaling service for resources beyond EC2, including ECS, DynamoDB, Aurora replicas, and AppStream, with scheduled scaling, target tracking, and scaling policies.

Prioritize decoupled components and stateless design, use asynchronous event-driven communication, choose scalable NoSQL databases with partition keys (like DynamoDB), and leverage cloud load balancing with auto scaling.

Compare schema-less NoSQL with denormalized data to SQL and normalized schemas to understand scalability. Use partitioning, sharding, and replication with thoughtful partition keys to enable independent, scalable partitions.

Explore Amazon RDS multi-az deployment in AWS console, including primary with readable standby db instances across availability zones, and create read replicas in standard class, memory-optimized class, or burstable class.

Amazon Aurora scales relational workloads with vertical scaling of the primary instance and horizontal read replicas (up to 15) across availability zones, plus automatic storage scaling across the cluster.

Learn how Amazon DynamoDB scales horizontally with automatic partitioning and global tables, using provisioned or on-demand throughput and RCUs and WCUs for read and write capacity.

Explore reliability in system design, measure mean time between failures, address chatty services, and apply RPO and RTO with AWS tools such as EC2, S3, and RDS.

Examine how chatty microservices calls affect performance in a brokered, asynchronous architecture. Learn to improve efficiency by integrating the subsidy logic into the contract service to reduce cross-service communication.

Learn MTBF and MTTF to measure reliability through total operating time divided by failures and distinguish repairable versus non-repairable components with a load balancer example.

Understand backup and disaster recovery mechanisms to protect data across compute, storage, and databases, using RDS backups, S3 versioning, cross-region replication, and AWS Backup.

Achieve high availability to keep components operational and accessible, measured by uptime percentages (nines), with AWS cloud support and deployment considerations across shipment, transaction, user, and order services.

Explore clustering and active-active setups that balance workload across redundant nodes with a load balancer to ensure high availability, noting synchronization and cost.

Create a bucket in AWS S3, define a lifecycle rule, and automatically transition objects to a storage class such as Glacier Deep Archive after a set number of days.

Explore globally distributed applications and learn how multi-region deployment ensures high availability for users worldwide. Discover how content delivery networks cache data per region to serve cross region requests efficiently.

Analyze deploying EC2 across regions for high availability, latency, and fault tolerance. Explore cross-region replication on S3 and global tables on DynamoDB for multi-region, multi-master architectures.

Explore how Amazon CloudFront integrates with services like S3, EC2, and Route 53 to cache objects at edge locations, accelerate dynamic web APIs, and improve DNS resolution.

Configure a CloudFront distribution with an S3 origin to host a static website, upload index.html and error.html, and set a bucket policy for public read access.