Explore building a microservices demo app with two resources, posts and comments. Learn how post creation and comment linking work and how asynchronous patterns enable cross-service communication.

Set up a microservices workflow with a React client communicating to Express-based post and comments services, using in-memory data and a three-project structure (client, posts, comments).

Create an Express post service with two routes: get all posts and create a post, storing posts in memory, generating IDs, parsing JSON bodies, and running on port 4000.

Manually test the posts service with Postman by posting JSON to /posts and verifying a 201 Created response with id and title, then retrieve all posts with GET /posts.

Implement a comments service with routes to create and list comments by post ID, storing in memory and generating random IDs from a content body, via Express.

Test the two express services on ports 4000 and 4001 with postman, create and fetch comments via /posts/{id}/comments, and prepare to solve issues with a microservices style React app.

Design and set up React app for the microservices project, implementing an app component with post create, post list, comment list, and comment create components, wiring Axios to Express API.

Create a post by submitting a simple form that captures a blog post title, sends it to the post service on port 4000 /posts via axios, and resets the input.

Configure cross-origin resource sharing (CORS) on the post and comments services by installing and wiring the cors middleware in Express, allowing browser requests between localhost:3000 and localhost:4000.

Fetch and render posts in a React app by wiring the post list to the post service with axios and useEffect, and display post titles as cards.

Create a React comment creation component that captures user input, posts it to the comments service for a given post ID, and displays under each post in the list.

Fetches comments for a post from the comments microservice using the post id passed from the post list. Renders each comment content in a list by mapping fetched data.

Explore request minimization strategies in microservices with Node.js and React, comparing synchronous and asynchronous communication to reduce multiple post and comment service fetches.

Explore asynchronous communication with an event broker and a query service to build fast, decoupled microservices that emit and process post and comment events, while weighing data duplication and complexity.

Explore common questions about asynchronous event architecture, including when to join data across resources without extra services, why independent services boost reliability, and handling corner cases with an event bus.

Build a simple, from-scratch event bus with Express in Node.js to publish events between services and learn the event flow behind a production-grade event bus.

Set up a basic event bus with Express and Axios, handling post /events and forwarding events to services on localhost ports 4001 and 4002, then listen on 4005.

Emit post created events to the event bus whenever a new post is added, including a type and data payload that the bus echoes to other services.

Emit a comment created event from the comments service to the event bus, including the comment data and post id, and observe how other services receive and handle these events.

Implement and test event handlers for the post and common services by receiving events from the event bus, logging event types, and preparing data for the upcoming query service.

Create a node express query service that aggregates posts and comments from post created and comment created events, exposes get /posts for listing, and accepts events at post /events.

Explore how the query service parses post created and comment created events to populate a post object with id, title, and a comments array.

Learn how a React app uses the query service on port 4002 to fetch posts with embedded comments, replacing direct calls to post and common services, demonstrating independent services.

Add a simple content moderation feature by creating a separate moderation service to flag comments containing the word orange, with statuses approved, rejected, or pending, avoiding hardcoded filters.

Explore how a moderation service filters comments in a microservice architecture. Trace the event-driven flow from comment creation to moderation and query persistence, and examine latency and user experience implications.

This second option emits comment created events to the moderation and query services, exposing the comment with a pending status immediately and updating it to approved or rejected after moderation.

Describe a two-event pattern for resource updates in microservices: domain-specific comment moderated events handled by the comments service, and generic comment updated events consumed by the query service.

Create a moderation service boilerplate, wire up an express API to listen for comment created events, and emit a comment moderated event on port 4003.

Add a pending status to new comments, emit a comment created event to update moderation and query services, and let moderation set approved or rejected based on orange presence.

Build moderation: consume comment created events, check content for orange to approve or reject, emit comment moderated event with id, post id, status, content, and route events via event bus.

Listen for the comment moderated event, locate and update the matching comment by id to approved or rejected, then emit a comment updated event to the event bus.

Update the query service to handle 'Comment Updated' events, locate the target comment in memory, and refresh its content and status, then test the moderation flow in the React UI.

Render comments based on status in a react app, showing approved content, or 'awaiting moderation' and 'this comment has been rejected' messages; explore moderation service downtime and event bus synchronization.

Learn how to handle missing events in a microservices architecture by storing all emitted events on the event bus and replaying them to services brought online later.

Store all incoming events in an array on the event bus and expose an endpoint to retrieve them, then have the query service fetch and process them on startup.

Explore how event syncing restores state after service outages by testing post and comment events, catching up via an event bus, and resyncing the query service.

Explore deploying a microservices app from local to online, address port mapping and event bus coordination across multiple servers, and consider Docker and Kubernetes for scalable deployment.

Docker creates isolated containers that wrap dependencies like node and npm, letting each service run independently with simple start-up commands, enabling 1-to-1 pairing and smoother production deployments.

Kubernetes runs containers across a node cluster managed by a master, uses configuration files to deploy and scale two copies of post service and streamline communication via a common channel.

Explore Docker and Kubernetes basics at your own pace, with an appendix that covers Docker essentials for beginners and upcoming videos that walk through Kubernetes basics for the microservices course.

Dockerize the posts service by creating a dockerfile with a node alpine base, building an image, installing dependencies, copying source, and starting with npm start.

Master essential docker commands: build -t, run, ps, exec -it, and logs. Build tagged images, run containers, access shells, and view logs to inspect services.

Reuse a single dockerfile and dockerignore to dockerize all node-based services, build and run images with npm start, and prepare the project for Kubernetes deployment.

Learn to set up Kubernetes locally for microservices, choosing an easy Mac/Windows path or a more involved Mini Cube route for Docker Toolbox or Linux, and enable container communication.

Verify Kubernetes is running with kubectl version. Follow how a post image becomes two pods managed by a deployment and exposed by a service across a cluster.

Explore essential Kubernetes terminology, including clusters, nodes, pods, deployments, and services, and clarify how Kubernetes services differ from application services for microservices.

Learn how yaml config files define Kubernetes objects (deployments, pods, and services), commit them to Git as documentation, and avoid creating objects directly in the terminal.

Create a single pod by writing a Kubernetes yaml file for one container using the posts image, then apply it with kubectl to run it.

Explore the pod spec in Kubernetes, detailing apiVersion, kind, metadata, and spec with containers and image settings, including versioning to avoid fetching from Docker Hub.

Learn how Docker commands map to kubectl and manage pods with apply -f, get pods, and describe pods. Run commands inside containers with kubectl exec, fetch logs, and read events.

Discover how to save time by using a shell alias, such as K for kubectl and DPS for docker ps, with setup tips for zsh and bash rc files.

Learn how deployments manage pods in Kubernetes, ensuring a chosen number of identical pods, automatically replacing failed ones and rolling out new versions.

Create and apply a deployment config that runs a single pod with the posts image version 001, using selector labels to manage pods.

Explore common commands around deployments, including listing deployments and pods, describing deployments, applying configuration, and deleting deployments to manage and repair workloads.

Discover two methods to update a deployment's image in Kubernetes, including rebuilding a new docker image version and applying config changes with kubectl.

Use latest image tag for deployments to avoid version errors in the config file. Rebuild and push the image to Docker Hub, then restart the deployment and verify logs.

Learn how Kubernetes services enable pod-to-pod and external access by using Cluster IP, Node Port, and Load Balancer, while noting External Name exists but is not used.

Create a node port service in Kubernetes by writing a config file and applying it to the cluster, exposing pods labeled app posts to the outside world for development purposes.

Run kubectl apply to create a node port service; inspect services, understand the random node port, and access the posts app via mini cube ip or localhost for development.

Deploy the event bus and configure cluster IP services for posts and the event bus to enable pod-to-pod communication within the cluster, despite pods having random IPs.

Build the event bus image, push to Docker Hub, create a deployment and pod, then configure cluster IP services for event bus and posts to enable in-cluster communication.

Co-locate deployment and cluster IP services to expose post and event bus pods. Configure cluster IP services in YAML, set selectors, and map ports 4000 and 4005.

Replace localhost URLs with the event bus and posts service names to enable pod-to-pod communication via cluster IP services and ports 4005 and 4000.

Update the post and event bus services to use the event bus service name and updated URLs. Rebuild and push images, restart deployments, and test event exchanges.

Verify inter-service communication in a Kubernetes cluster by sending a post request via postman and confirming the post pod emits a post created event to the event bus, via logs.

Update comments, query, and moderation to post events to the event bus CRV, replacing localhost. Build and push images, deploy cluster IP services, and apply configs for testing.

Update the event bus to reach cluster IP services for comments, query, and moderation, then rebuild, push to docker hub, and test events from event bus with postman and logs.

Integrate the React development server inside a Kubernetes pod and expose a load balancer service as the single entry point, routing browser requests to the appropriate cluster IP pods.

Learn how a load balancer service provisions external traffic into a Kubernetes cluster, and how an ingress controller routes requests to pods using path-based rules.

Install ingress nginx with ingress engine x to deploy a load balancer and an ingress controller in your cluster, using kubectl apply -f and avoiding Kubernetes ingress confusion.

Create and apply an ingress config to route requests to the post service via a cluster IP service on port 4000, using annotations for the ingress class Engine X.

Learn how to use Ingress Engine X to host multiple apps on a Kubernetes cluster, map domains with the host file, and route traffic to local or Minikube IPs.

Update host file for development to route the React app to the post service on the local machine; push a Docker image and configure Kubernetes ingress with cluster IP service.

Define unique route paths in ingress to differentiate post and query requests, updating React and post services to handle /posts/create, then rebuild images and restart deployments.

Configure final route config in Kubernetes ingress to route post creation, posts, and comments to microservice backends, using regex for wildcard paths and Engine X annotations.

Use scaffold to speed updates to running pods in a Kubernetes dev environment, enabling quick code changes, easy object creation and deletion, and seamless project switching.

Install Scaffold dot HTML file to manage Kubernetes manifests in the infra aids directory. Scaffold watches manifests, applies on start, and deletes related objects on stop.

Run scaffold dev from the project root to start the scaffold. The first startup rebuilds six images and may show warnings, not found messages, or uncommitted changes as it initializes.

Learn to use Skaffold to run and debug microservices with node and React, troubleshoot manifest unknown errors, and leverage automatic rebuilds and logs from pods for rapid iteration.

Build large microservices with a shared library, clear event contracts, and async communication, using TypeScript and tests to ensure data consistency and handle out-of-order events.

Build a production-grade ticketing app with microservices, featuring 15-minute purchase locks, user authentication, Stripe payments, and an event-driven architecture using Node.js and React.

Explore the four core resources for the app—users, tickets, orders, and charges—detailing their fields, relationships, and Stripe-based payment flow, including order expiry and status transitions.

Design five microservices for authentication, tickets, orders, exploration, and payments, each handling its resource domain, and weigh whether one service per resource is best.

Learn the architecture of a microservices app with Node.js and React, covering events like user created and order expired, plus Next.js SSR and a NATS streaming event bus.

Build an auth service with sign up, sign in, sign out, and current user routes using TypeScript and express, supported by a Node.js development setup.

Build a docker image for the auth service from node alpine, using a dockerfile and dockerignore, then deploy a Kubernetes deployment and service on port 3000.

Add and configure a scaffold yaml file to watch the infra directory and sync auth changes to the running container, enabling automatic cluster updates with scaffold dev.

Configure ingress nginx to route api/users to the auth service, enabling manual testing with postman; define host tickets.dev and ticketing.dev and map /api/users to the CRV service on port 3000.

Configure the hosts file to route ticketing dev to the local Ingress Engine X server. Resolve self-signed certificate warnings in development and test the authentication flow via the ingress setup.

Learn how to run your development in Google Cloud to avoid lag from multiple pods, with an optional setup and access to $300 in free credits.

Set up a remote development environment on Google Cloud using Skaffold to manage Kubernetes pods, deployments, and automatic syncing of code changes.

sign up for a google cloud account to obtain $300 in free credits, then create a new project in the google cloud console and configure billing details.

Learn to switch between kubectl contexts to access different Kubernetes clusters, including your local Docker cluster and a Google Cloud cluster, by using the Google Cloud SDK to auto-manage contexts.

learn to use gcloud to fetch credentials for your Google Cloud Kubernetes cluster and switch kubectl contexts between Docker Desktop and the ticketing-dev cluster.

Enable Google Cloud Build to build images from source, update the Skaffold configuration, set up Ingress Engine X on the Google Cloud cluster, and update the host file before restarting scaffold.

Update the scaffold html to keep only one build option, local or google cloud. Update the deployment to use the new image name by applying the scaffold's image name.

Learn how to install Ingress Engine X on a Google Cloud cluster, expose a load balancer, and update host file to route traffic to the deployed back end server.

Restart scaffold, build a remote image with google cloud build, and deploy deployment, service, and ingress to a remote cluster; verify build in cloud build history and test domain access.

Organize authentication by creating four route handler files (sign up, sign in, sign out, current user) as express routers in a roots directory and wire them into index with app.use.

Scaffold and wire up authentication routes by duplicating a root handler across sign in, sign out, and sign up files, and attach routers to the Express app.

Add validation to the sign up route by using express-validator to require a valid email and a trimmed password, via middleware that checks the request body and provides error messages.

Use express validator and validation results to detect email or password errors in signup requests, returning a 400 with the errors array, then proceed when validation passes.

In a microservices architecture, this lecture explains the importance of consistent error responses across services and plans a shared library to unify validation error formats for the React frontend.

Establish a single, consistent error response structure across all services, from Express Validator failures to database outages, so the React app can parse errors uniformly.

Implement a consistent error handling strategy with an Express middleware, capturing errors from synchronous and asynchronous routes via next for a unified response.

Create an error handling middleware in a Node.js and Express project with a four-argument signature and TypeScript annotations, delivering a consistently structured error response.

Improve error handling by attaching detailed validation results to the error object and delivering a well-structured response that tells users exactly what went wrong. Emphasize TypeScript-style handling over plain JavaScript.

Subclass the built-in error with TypeScript to create request validation error and database connection error, adding custom properties like reasons to convey rich information to the error handling middleware.

Create custom error subclasses for Node.js microservices, including request validation error and database connection error, and apply them in a signup route with express validator and centralized handling.

Implement error type detection in the error handling middleware by distinguishing request validation errors and database connection errors, logging each case, and building a reason-based response for the client.

Map every error to a common response structure using a central error handling middleware, producing an errors array of messages and optional fields for validation and database errors.

Refactor error handling by adding serialize errors and status codes to request validation and database connection errors, letting the error handler produce a unified response and prevent middleware bloat.

Improve error handling middleware by enforcing a consistent serializeErrors output for custom errors. Compare using an interface versus an abstract class to ensure status codes and structure across all errors.

Create a custom abstract error class that enforces a status code and serializeErrors, have request validation and database errors extend it, and unify the error handling middleware for consistent responses.

Define a new custom air to handle route not found, export a Not Found Air class, set a 404 status, implement serialize errors, and rely on Express middleware to send the response.

discover how async error handling in express works, including the async keyword returning a promise and using next(error); install and import express-async-errors to auto-catch errors in async route handlers.

Install mongoose in the service and create a private MongoDB instance in Kubernetes. Configure a deployment and a cluster IP service to expose MongoDB on port 27017 for signup.

Connect the auth service to MongoDB with mongoose using async/await, handling startup with a start function and logging success or errors before listening for traffic.

Explore the signup flow: validate unique emails using a mongoose user model in MongoDB, hash passwords, create the user, and return a token or cookie for sign-in.

Explore how TypeScript and Mongoose cooperate in a microservices project using a Mongoose user model and a user document, and tackle two big issues around constructor properties and document fields.

Create and export a Mongoose user model by defining a schema with email and password, then expose a model to access MongoDB data, while highlighting TypeScript type gaps.

Learn to enforce TypeScript type checking with Mongoose by introducing a user adders interface and a buildUser function, ensuring emails and passwords are correctly typed when creating users.

Refactor the user model to include a static build method via schema statics, enabling user built with email and a password, and address TypeScript typing for mongoose models.

Define a user document interface to align create user properties with Mongoose document fields, include created at and updated at as needed, and replace any with user doc in model.

Explore how TypeScript generics use angle bracket syntax to customize function types. See how the model function returns the type defined by the second generic argument.

Create a user model and signup flow in the microservices with Node JS and React course, including email duplication checks, password hashing, saving to MongoDB, and Postman testing.

Learn to implement a custom bad request error for the signup route, return actionable messages when an email is in use, and prepare for password hashing and a JWT cookie.

Hash passwords during signup and store only the hashed version in the database, replacing plain-text storage; on sign in, hash the input and compare to verify credentials.

Implement password hashing during signup by placing hashing logic in a separate services/password class with static hash and compare methods, returning hash and salt joined by a dot.

Implement static compare method to verify a supplied password against the stored hash and salt by splitting stored password to extract hash and salt, then hashing input and comparing.

Implement a mongoose pre-save hook in the user model to hash passwords automatically. Hash only when modified, using a function keyword and done callback, ensuring plaintext passwords are never stored.

Explore authentication strategies for microservices, comparing centralized authentication with JSON web tokens or cookies in a gateway versus independent service-level checks; highlight trade-offs like single points of failure and duplication.

Examine the drawbacks of option two, where each service authenticates independently, removing the central auth dependency but risking valid tokens after bans and cross-service inconsistency.

Compare central authentication versus per-service authentication for microservices; opt for independent services with async communication, while acknowledging a brief window before bans propagate, and plan a hybrid approach.

Implement option two by enforcing short-lived JWTs of 15 minutes with optional token refresh, and use event-driven bans and short-lived caches to revoke access across microservices.

Clarify how cookies differ from JSON web tokens and how each supports authentication and authorization, including storage, transport, and usage in a microservices architecture.

Assess json web tokens and cookies for authentication, then adopt a jwt approach that stores user details and authorization, encodes expiration, and supports multi-language use without a backing store.

Explore how JSON web tokens are communicated to backend services in server-side rendered React apps, using cookies with Next.js to securely pass authentication on the initial request.

Authenticate users with json web tokens stored in cookies, using cookie session to manage token data without a backing data store.

Install and configure cookie session in an express app, including TypeScript typings, enable https-only cookies, trust the proxy, and generate a json web token stored in a cookie.

Generate a JSON Web Token, signing a payload with the user's id and email, then store it on the cookie session for authenticated requests and verify the token when needed.

Learn how a session becomes a JSON web token, verify its signature with a signing key, and inspect the payload while exploring key sharing across services via Docker and Kubernetes.

Securely share the JSON web token signing key across microservices by creating a Kubernetes secret and exposing it as environment variables inside each pod.

Create and bind a generic secret in a Kubernetes cluster, expose it as an environment variable via a deployment's secretKeyRef, and debug not-found errors with describe and get pods.

reference the JWT key from the pod’s environment variable, validate the variable at startup, throw an error if undefined, and use a non-null assertion in TypeScript while avoiding hard-coded secrets.

Remove password and __v from signup responses and remap _id to id to ensure consistent front-end data across microservices using Node and Express and MongoDB.

Customize how user documents turn into JSON by using mongoose's toJSON transform to remap _id to id, remove password, and omit the version key.

Wire up the sign-in router; validate email and password with express-validator; verify the user in MongoDB, issue a json web token in a cookie, and prepare reusable validation middleware.

Extracts validation into a reusable express middleware named validate request, throws request validation errors via validation results, and calls next when valid in signup and signin routes.

Implement sign in by validating credentials, querying MongoDB for the user by email, and comparing the provided password to stored hash. Then issue the json web token in a cookie.

Implement and test sign up and sign in using Postman with a test email and password, validate credentials and cookies, and plan to add current user and logout routes.

Create a current user route handler that lets the React app verify sign-in by checking the session json web token and return the payload as current user when valid.

Implement a current user route using JSON Web Token and cookie session, decoding and verifying tokens with a try/catch, returning the payload when valid or null when not.

Learn how to sign out a user by clearing the cookie session with cookie-session, removing the JSON web token, and returning an empty response for subsequent requests.

Create a current user middleware that decodes the json web token payload and attaches user data to request. Pair it with login-check middleware to guard routes and support downstream handlers.

Augment the express request type to include an optional current user property by defining a user payload interface and declaring augmentation, enabling middleware to attach the json web token payload.

Develop a require-auth middleware that rejects unauthenticated requests by checking the current user property, throws a not-authorized error, and enforces access on protected routes.

Define the scope of testing in a microservices environment, from unit tests of a middleware to integration tests across components and services.

Explore testing goals for microservices by examining basic request handling, model unit tests, and future event emitting and receiving, all run locally with npm run test against Node.js and MongoDB.

Wire up testing architecture with Gest, in-memory MongoDB, Express, and Super Test to send requests and assert results, exporting the app for testing on an ephemeral port.

Refactor the express setup by creating a dedicated app file, exporting the configured app, and importing it into index to wire middleware and mongoose for future in-memory MongoDB testing.

Install development dependencies with npm install --save-dev, including @types/supertest, supertest, and mongodb-memory-server for in-memory multi-service tests, and adjust the Dockerfile to skip dev dependencies during builds.

Set up a jest-based test environment for a node microservice with TypeScript support, a MongoDB memory server, and setup files to isolate data across tests.

Learn to write a basic signup route test for a Node.js Express app using Jest and Supertest, including test file structure, post requests, and jwt key setup.

The lecture notes that jest enables TypeScript support, and that tests can fail to reflect changes; restart the test runner and re-run npm test to update results.

Develop and run input validation tests for the sign up route using super test; verify that invalid email, invalid password, or missing fields return a 400 status.

Write a test to prevent duplicate emails by posting the same email and password twice to the sign-up API, expecting 201 on the first and 400 on the second.

Develop tests for the signup route to confirm 201 response and a set-cookie header, inspect the response with supertest, and adapt cookie session security to false in the test environment.

Write tests for the sign in request handler, verifying 400 for non-existent users or incorrect passwords, and 200 with a set-cookie header for valid credentials.

Develop a test that signs up a user, ensures authentication, then signs out and verifies the set-cookie header clears the session, asserting a valid response.

Learn how to test the current user endpoint by signing up and querying authentication, and tackle cookie handling in tests to enable authenticated requests across services.

Capture the authentication cookie from the initial response and include it in the follow-up request by setting the cookie header. Refactor into a helper to simplify authenticated testing across services.

Create a global async sign-in helper in the test setup to sign up a user, capture the authentication cookie, and perform authenticated follow-up requests in tests.

Test non-authenticated requests by sending a get request to the API users current user, without cookies, and confirm the response returns current user as NULL with status 200.