Learn Microservices with Dockers (A Project Based Learning)

Explore the theoretical foundations of microservices, compare monolithic, modular, and service-oriented architectures, and outline microservices characteristics, benefits, and challenges.

Explore monolithic architecture as a traditional single unified unit where UI, business logic, and database interactions are tightly integrated. Learn its simplicity and historical use in small apps.

examine the limitations of the monolithic approach, including high code coupling, testing difficulty, reduced flexibility, and limited reusability. discover how modular architecture addresses these limitations in the next video.

Explore modular architecture by dividing an app into independent modules that each have their own business logic and database schema, and connect them to a single database.

Explore the advantages of modular architecture, including fault isolation, parallel development, separation of concerns, scalability, and reusability, to reduce complexity and enable independent module growth.

Compare monolithic and modular architectures using an Uber-like case study, showing how tight coupling in monolithic designs complicates updates and scaling, while modular subsystems enable targeted changes.

Trace the evolution from functions to modules, packages, and components, and examine language dependencies and integration challenges, then see how service oriented architecture overcomes these modular limitations.

Explore service oriented architecture as a language independent, modular design where independent services communicate over a network via well defined interfaces using SOAP and JSON (XML formats) for data exchange.

Examine the limitations of service oriented architecture, where independent services still rely on a shared back end database, causing bottlenecks, and introduce microservices as a more flexible, scalable decoupled solution.

Explore microservices as small, independent, loosely coupled units with own databases and diverse tech stacks, routed by an API gateway for flexible, scalable architectures.

Learn the key microservice traits: autonomous, loosely coupled units with isolated databases, organized by business capabilities, smart endpoints with dumb pipes, and decentralized governance and data management.

Learn how microservices boost agility, scalability, and rapid feature delivery through independent deployment, targeted scaling, small focused teams, modular code bases, data isolation, and flexible tech stacks.

Explore the challenges of microservices, including increased overall complexity, deployment automation needs, and network latency, and learn fault-tolerance techniques like retry, circuit breakers, fallbacks, and load balancing.

Explore requirement analysis and microservices design to align functionalities and service interactions with business goals, translating requirements into scalable, fault-tolerant, resilient, secure, and maintainable system design.

Analyze requirements for microservices using an online shopping case study. Identify stakeholders, draft use cases, and derive functional requirements to build a domain model with nouns and verbs.

Identify the key stakeholders: customers, admins, and vendors in an online shopping system, and outline their roles, operations, and interactions for domain analysis.

Learn how to create a use case diagram to map interactions between users and admins, detailing registration, profile management, product search, orders, queries, catalog management, and reports.

Explore customer registration, admin product catalog management, and browsing and searching use cases, using a template of use case name, actor, preconditions, main flow, and postconditions.

Define the final functional requirements for a microservices system from domain analysis. Include user registration, login, email confirmation, social logins, and payment methods, plus order history and shipment tracking.

Learn to map product, cart, order, payment, admin, and support requirements into domain models for microservices, guiding domain analysis in docker-based projects.

Identify entities and associations from requirements to build a domain model that visualizes the relationships between order, shopping cart, product, customer, and checkout; prepare for microservices design.

Identify candidate microservices by refining domain analysis and modeling, cluster bounded contexts, define service boundaries, and establish communication patterns for a four-step microservices design.

Identify candidate microservices by filtering out vague terms, retaining clear domains like user, product, report, payment, and inventory to form a defined foundation for the architecture.

Identify bounded contexts by clustering related entities within the domain model to form cohesive microservices, such as user management, order handling, reports, inventory, cart, and checkout.

Define boundaries and responsibilities for each microservice by assigning functional requirements to dedicated services, ensuring cohesion and validating scope across user management and product catalog management service.

Identify integration points, choose the communication protocol, and define APIs and contracts for the stage of microservices design, comparing synchronous and asynchronous communication with asynchronous offering greater efficiency and scalability.

Learn how application programming interfaces enable cross-system communication by exposing endpoints and methods, handling requests and responses in JSON or XML, with real-world examples like weather APIs and Google Maps.

Explore representational state transfer as an architectural style for designing networked applications. Learn how REST uses a client-server model with HTTP methods and JSON resources for interoperable, scalable web services.

Explore the five fundamental REST architecture characteristics: statelessness, uniform resource identifiers, cacheability, client-server architecture, and layered systems. See how these principles enable scalable, resource-based APIs for microservices.

Explore how containers bridge theory and practice in microservices development. Learn Docker architecture, installation, and the key steps to containerize an application for practical use.

Package each microservice with its dependencies in a lightweight, portable container, like PHP and Apache, to ensure the microservices run consistently across environments via container images.

Explore how virtual machines, via hypervisors, virtualize hardware with separate OSes and licensing costs, and how Docker Engine containers share a single host OS for lightweight app deployment.

Explore the key features of containers: isolation, shared host resources, lightweight architecture with a single kernel, and portability that bundles code and dependencies for consistent cross-environment running.

Learn how Docker, a software platform to manage containers, builds, runs, and ships applications using a client–server architecture, with a Docker client and Docker engine communicating via a rest api.

Compare docker desktop and docker engine (cli), advocate using the engine for servers and headless environments due to lower resource use and greater control.

Install Docker Engine and Docker Compose via apt repository, avoid conflicts with Docker Desktop, and verify with docker --version, docker version, docker info, and docker compose version.

Learn to containerize an application with Docker by writing your microservice code, creating a Dockerfile, building a Docker image, and running a container.

Write Docker files and generate images to containerize applications, using image registries to manage builds. Prepare to build and run containers across PHP, Node.js, React, and Python.

Explore how a Dockerfile serves as a blueprint for constructing a Docker image, automating image creation, and configuring the environment for your code or microservice.

Learn the structure of Dockerfile to define dependencies for PHP with Apache and Node.js apps, including from PHP 8.2-apache, workdir, copy, extensions, expose, and npm start.

Create a Docker file to pull the PHP and Apache image from Docker Hub, set the working directory to /var/www/html, and copy index.php from the host.

Explore how docker images are immutable blueprints built from application code and a docker file, packaging libraries, environment variables, and config to run a container without manually installing dependencies.

Learn how to create Docker images for a PHP and Apache app by writing a Dockerfile, building with Docker build, naming the image first app, and reviewing existing images.

Watch a quick demo of creating and running a container from an image with docker run -d -p 5000:80 first app, and verify access at localhost:5000.

Explore sharing Docker images on Docker Hub, including official and unofficial registries, with examples like Python, MongoDB, and Ubuntu. Learn to read image docs and pull or push repositories.

Learn to pull images from Docker Hub using docker pull, selecting the Python 3.8 slim tag, and verify downloads with docker images.

Push your locally tagged images to Docker Hub using docker push after tagging with your username and repository name.

Create and manage Docker containers across languages including Node.js, PHP, React, Flask, HTML, CSS, and JavaScript. Explore data persistence with volumes and mounts, gaining practical experience running applications inside containers.

Learn how to run a docker container from an existing image in detached mode, troubleshoot foreground execution, and prepare port mapping to access the app in a browser.

Learn how to map a host port to a container port to run applications inside Docker containers. Use ports like host 3000 and container 80 to expose apps via localhost:3000.

Learn to start and stop docker containers, view running or all containers with docker ps and docker ps -a, and verify status after starting or stopping using container IDs.

Learn how to name docker containers with docker run --name, see how docker assigns random names via docker ps -a, and verify containers with docker ps.

Learn to remove containers with docker ps and docker rm, either stopping first or force removing with docker rm -f, then verify cleanup with docker ps.

Learn to remove all docker containers at once by listing containers with docker ps -a, extracting IDs with docker ps -a -q, and passing them to docker rm.

Learn to run containers in interactive mode with docker run -it, log into the container, and verify php code and its dockerfile are correctly located inside the container.

Access containers by creating a docker container in detached mode with docker run -d, then log in with docker exec -it <container> /bin/sh to inspect the root directory with ls.

Learn how data persistence works in Docker using bind mounts or volumes. Store files on the host so they persist after container removal and reflect changes across host and container.

Demonstrate data persistence by binding a host directory to a container directory with docker run -it and the -v option, showing changes reflect and survive container removal.

Learn to containerize a simple HTML, CSS, and JS weight converter using Nginx and Docker, building an image and running a container on port 3005 to serve static content.

Containerize a Node.js application using a dockerfile with node alpine, copy package.json, npm install, expose port 3000, and run the container with port mapping 3001:3000 to view the welcome app.

Containerize a hello world react app by building with a dockerfile rooted in node 16 alpine, installing dependencies, building the production build, and serving with serve.

Learn to containerize a Flask app with Docker by building a Python 3.9 slim image, copying files, installing Flask, exposing port 5000, and running the container accessible at localhost:3000.

Containerize a PHP calculator app using a Docker image with Apache 8.2 and expose port 80 for post form input that performs addition, multiplication, and division.

Explore running multi-container applications with docker compose across front end, back end, and database containers. Learn how to structure docker-compose.yaml and docker networking for a cohesive, microservice-inspired development environment.

Define and manage multi-container docker applications with docker compose, configuring services, networks, and volumes in a single docker-compose.yaml, and scale while using .env for environment variables and persistent storage.

Learn how the docker-compose.yaml file defines multi-container applications by detailing services, networks, and volumes, and serves as a blueprint for your application's architecture by coordinating container interactions.

Learn the structure of docker-compose.yaml version 3.8, define services, volumes, and networks, and containerize front-end and back-end microservices with build contexts, ports, and binding volumes.

Explore docker networking in docker-compose, using default and custom networks to enable inter-service communication among web service, application logic, and database, while controlling access and security.

Dockerize your first multi-container app by building a front end service with nginx and a back end service with PHP on Apache, using Dockerfiles and a docker-compose.yaml.

Develop the front end of a two-container dockerized app in step one, using a dockerfile with nginx, and prepare for back end and docker-compose integration in upcoming steps.

Create and connect a PHP backend microservice with a simple front end, using a Dockerfile to define dependencies and plan to configure the front end and back end with docker-compose.yml.

Define a docker-compose.yaml 3.8 to run front end and back end as separate services, bind host directories to containers, and configure nginx and apache on a shared app-network.

Demonstrates running a multi-container application with Docker Compose, building images, and creating containers. Access front end on port 3001 and back end on port 3002, terminate with Docker Compose down.

Demonstrate how docker volumes bind host directories to containers, enabling real-time updates to frontend and backend code without rebuilding images, and simplify development by restarting containers to reflect changes.

Embark on project based learning with a three microservice application: a frontend container, two PHP backends, and a database; learn Docker files and Docker Compose to run, connect, and scale.

Define the front end microservice with HTML, JavaScript, and CSS, featuring two buttons that route to backend microservices, and outline its nginx-based Dockerfile and Docker Compose setup.

Develop the first backend microservice in PHP with a two-field web form that inserts user data into a MySQL database, packaged in a Dockerfile using a PHP Apache base image.

Define the second backend microservice to fetch data via a database connection and a simple sql select; the dockerfile remains similar to step two, using php and apache.

Define the docker-compose.yaml to connect three microservices—front end service and two back end services—using builds, volumes binding host and container directories, ports 3001 and 3002, and the App network.

Adds MySQL and phpMyAdmin services to the Docker Compose setup, with persistent volumes, root user config, and app network, exposing phpMyAdmin on port 3004; defines a five-container architecture.

Demonstrates running the app with Docker Compose, building front end and back end images, and managing MySQL data via phpMyAdmin, with front end on port 3001 and phpMyAdmin on 3004.

Containerize a microservices project with a Node.js backend and MongoDB, using Docker and docker-compose to serve JSON from localhost:5000/movies to the front end.

Set up a backend microservice with Node.js, connect to MongoDB, and expose a REST API that serves movie data in JSON, then containerize with a node:alpine Dockerfile and port 5000.

Define front end service to fetch JSON from the back end API at localhost:5000/movies, render it in a tabular layout with html, css, and javascript, and prepare for docker deployment.

Analyze the docker-compose.yaml that defines a four-service microservices architecture, including front end API, MongoDB, and Mongo Express. Understand port mappings, build instructions, dependencies, and network setup for proper startup.

Configure and connect MongoDB and Mongo Express in docker-compose, using MongoDB 6.0 image, port 27017, dedicated data volumes, and a web-based GUI on port 8081.

Build and run a dockerized full-stack application with a frontend in HTML, CSS, and JavaScript, a Node.js backend with a MongoDB database, and a REST API, orchestrated by Docker Compose.

Develop and containerize a multi-service application using Docker, MongoDB, and a Node.js Rest API. Build cross-language microservices in Node.js, PHP, and Flask, coordinating with Docker Compose.

Develop a node.js rest api connected to mongodb, exposing json data through an endpoint, with a dockerized deployment using a similar dockerfile as prior projects.

Learn how a Flask microservice fetches JSON data from a Node.js API, processes it for the front end, and runs in docker-compose with API service naming.

Explore how a PHP microservice communicates with a Node.js API, returns JSON, and formats data with HTML and CSS, using a PHP 8.2-apache Dockerfile and port 80.

Configure the docker-compose.yaml to connect flask, PHP, and api services with MongoDB and Mongo Express, using build, container names, ports, depends_on, and the my network.

Run a multi-service application with a Node.js backend, MongoDB, and Flask and PHP microservices that fetch data from the API and render it in JSON and tabular formats.