Building real-world Multitenant application

Install VirtualBox and a Ubuntu VM, then install Docker inside the VM to pull, build images, manage volumes, and use Docker Compose with YAML in a hands-on exercise.

Visualize a Windows host running Oracle VirtualBox to host a Windows VM, install Docker inside the VM, and use the Docker CLI to pull images and spawn multiple containers.

Install VirtualBox on Windows by downloading from virtualbox.org, run the straightforward setup, and launch the VirtualBox manager to prepare for Ubuntu installation in a future video.

Download the Ubuntu ISO, create a VirtualBox VM with adequate memory and a dynamically allocated SSD disk, enable Guest Additions for copy-paste and drag-and-drop, and set up a shared folder.

Explore docker architecture from the daemon to containerd and runc, and how containerization decouples management from the GUI. See how namespaces and cgroups create isolation for containers on a host.

Install docker on linux using snap or apt, run sudo apt install docker.io -y, then add your user to the docker group and verify the installed version (about 19.03.8).

Explore how docker pull retrieves images via the REST API and Docker daemon, using local cache and registries like Docker Hub or private registries, with tag management and latest pitfalls.

Explore docker basics by running containers in detached mode, mapping host port 80 to container port, and managing container life cycles with run, ps, start, stop, exec, and rm.

Explore Docker network drivers by default (bridge, host, none) and master essential commands for managing networks, images, and containers, including Docker network, Docker images, and Docker rmi.

Build a custom docker image with docker build from a base tomcat with jdk 11, copy your war, run the container exposing port 60-62, and troubleshoot with docker logs.

Learn how to mount volumes in docker containers, compare binding mode with named volumes, and persist data across container lifecycles.

Explore Docker Compose through a hands-on lab, learning YAML-based service definitions, networks, and how to deploy containers on a single host.

Explore a high-level overview of Docker Swarm, its limitations for production in multi-host container environments, and core concepts like managers, workers, services, and replicas.

Demonstrates multi-stage docker builds by separating build and runtime to produce a skinnier production image, building with Maven, creating a built artifact, then copying it into a Tomcat-based final stage.

Learn to implement Docker multi-stage builds to create a smaller production image. Compare single-stage and multi-stage approaches, manage containers, expose ports, and clean up resources in a hands-on lab.

Install and explore Ansible through a hands-on lab, then delve into core concepts—tasks, playbooks, and rules—while understanding how Ansible underpins the Operator SDK.

Explore Ansible fundamentals by configuring a control node, managing containers, and using inventory, playbooks, modules, plugins, and Ansible Galaxy to automate tasks.

Discover how Ansible simplifies multi-node management with a web GUI and core binaries—Ansible, Ansible playbook, and Ansible Galaxy—plus a preview of Galaxy collections and cluster setup.

Build a custom image to run an Ansible control node in a container for a multitenant environment, configuring public/private keys to manage nodes with Ansible.

Set up a multi-container Ansible lab by building a control node and two managed nodes, installing Ansible, configuring SSH keys, and exposing ports for Apache on containers.

Run hands-on Ansible tasks using the command line and playbooks, configure managed nodes, update inventory and host mappings, and explore inventory groups and setup facts in a multitenant environment.

Walk through creating and running an Ansible playbook that executes a sequence of tasks on a defined group, using modules like shell, ping, set up, and debug, with facts gathering.

Master practical troubleshooting in a hands-on ansible lab by inspecting containers, diagnosing ephemeral data on restart, and persisting changes through image customization and selective package installation.

Participate in a hands-on Ansible lab to troubleshoot playbooks across two containers using Ansible Tower, installing and removing a package with apt, and gathering interfaces and IP addresses.

Explore Ansible roles and handlers to automate configuration with a standard file structure, and see how notifies trigger handlers to restart services.

Execute a hands-on ansible lab to create and run an ansible role, build a proper inventory and playbook structure with Ansible Galaxy, and install then uninstall a package across hosts.

Install and explore a minuscule cluster. Learn the control plane and data plane, workload resources, storage with persistent volumes, networking with services and ingress, and rbac security through hands-on labs.

Install minikube and kubectl utilities to manage cluster resources. Download binaries, move them to /usr/local/bin, and source your shell to apply path changes.

Start a minikube cluster with the none driver in bare metal mode, adjust VM CPU and virtualization, then copy kubectl config and certificates for access.

Learn to start Minikube with the none driver and troubleshoot errors from the protected regular file flag. Use a supported driver or disable the flag, with proper privileges.

Discover how to start Minikube with the docker driver, compare it to none and bare metal, enable ingress, and manage profiles and contexts.

Master the Kubernetes control plane by examining apiserver, etcd, controller manager, scheduler, kubelet, and kube-proxy, and see how minikube adds DNS and persistent storage components.

Explore Kubernetes data plane components for building multitenant applications, including kubelet, kube-proxy, and docker engine, and how they report resources to influxdb and rafina dashboards; heapster deprecated for matrix servers.

Discover Kubernetes pods as the smallest deployable unit, hosting one or more containers that share an IP and Linux namespace; a primary container starts the namespace, with optional sidecars.

Explore deploying real-world Kubernetes pods by crafting YAML for single-container and multi-container pods, using namespaces, labels, and images like BusyBox and a web server, and verify with kubectl.

Explore Kubernetes pod debugging in real-world multitenant clusters by using logs, exec, and namespace options to troubleshoot single container pods and inspect shared IPs.

Configure Kubernetes deployment using a YAML file to declare the desired state, manage three replicas via a replica set, and understand how templates, labels, and image pull policies control containers.

Deploy a three-replica Kubernetes deployment with a custom image, using a yaml manifest and replica set logic, and route traffic via a service that implements round-robin load balancing.

Explore Kubernetes service as an abstract network resource that exposes a set of pods and routes traffic through a proxy, with types like ClusterIP, NodePort, LoadBalancer, and ExternalName.

Create a kubernetes service from a yaml file, set the BHB service to port 30080, use a selector for the app, and demonstrate traffic routing via a proxy.

Explore Kubernetes ingress as a resource that exposes external services and enables host-based and path-based routing via an ingress controller, with annotations and rewrite rules.

Create and expose a multitenant Kubernetes app using ingress, deployments, and services; configure custom docker images, an ingress resource, and troubleshooting steps to route external traffic.

Explore Kubernetes RBAC by mapping roles, rules, and subjects to grant namespace or cluster-wide access. Learn how service accounts, bindings, and YAML define who can do what across resources.

Master Kubernetes RBAC and API groups to grant precise, namespace-scoped access through role bindings. See how service accounts use tokens to access resources and how restrictions affect commands.

Learn how ConfigMap and Secret differ, what they store, and why base64 encoding is not real encryption; explore encryption at rest, encryption provider config, and envelope encryption for secrets.

Configure Kubernetes config maps and secrets, mount files as volumes in a deployment, and manage access via service accounts, highlighting differences between non confidential config data and confidential secret data.

Compare static provisioning, where cluster admins create pv and bind to pvc without a storage class, with dynamic provisioning using a storage class to automate pv creation.

Explore Kubernetes storage concepts by contrasting static and dynamic provisioning using PV, PVC, and storage classes, including disabling dynamic provisioning and returning to static provisioning to make it work.

Deploy Kubernetes resources using Ansible by building a custom image, running a control node in a container, and looping over a variable list to create three deployments and three services.

This hands-on lab demonstrates using Ansible to deploy Kubernetes resources via an Ansible Galaxy role, deploying deployments and services with templates and collections.

Deploy Kubernetes resources with Ansible in a hands-on workflow, creating three deployments and three services via a single role and YAML, managing present and absent states.

Learn how to set container CPU and memory requests and limits, implement limitRange and ResourceQuota at the namespace level, and prevent hogging in multitenant Kubernetes deployments.

Explore Kubernetes resource management across namespaces by applying requests and limits, LimitRange and ResourceQuota, then validate scheduling and pod availability through hands-on lab steps.

Explore Kubernetes QoS classes—guaranteed, possible, and best effort—and how memory and CPU requests and limits in YAML drive scheduling and eviction decisions.

Master taints and tolerations, node selectors, and affinity—covering soft preferences and hard requirements—for precise pod scheduling, eviction, and placement in a multitenant app.

Master the k8s operator pattern and operator sdk framework, focusing on the control loop, custom resources and the operator controller that automate deployments, config maps, services, and ingress.

This hands-on lab uses the operator sdk to build a real-world multitenant portal. Deploy tenant portals in separate namespaces with ingress, services, and config maps.

Build a custom operator for a multi-tenant portal, validate architecture, run a custom image, and copy files between Docker engine and Ubuntu VM.

Explore a hands-on lab on building a multitenant portal with the Operator SDK, defining custom resources, and deploying Kubernetes resources like config maps, deployments, services, and ingress across namespaces.

Build a custom operator for a multi-tenant portal by generating boilerplate yaml files, defining custom resources and crds, and configuring deploy templates, certificates, and environment variables.

Deploy a multi-tenant portal with the Operator SDK on a Minikube cluster using docker driver; build an ansible operator image and watch resources with the Worchester Yamal file via ingress.

Deploy and manage a multi-tenant portal with a custom operator controller and resource, using kubectl, minikube, and ansible to create isolated portals in separate namespaces.

Introduction to Istio control plane and data plane, clarifying API gateway versus service mesh, and outlining core components such as pilot, citadel, galley and sidecar proxies for labs.

Explore the Istio book info lab architecture from an external user view, detailing ingress, egress, gateway, and destination rules across microservices like product page, details, and reviews.

Learn how Istio book info components gateway, virtual service, and destination rule interact to route traffic, define destinations, and enforce traffic policies, including mutual TLS, via YAML deployments.

Execute Istio bookinfo commands to build the hands-on lab, enable sidecar injection, deploy the bookinfo components, and set up the gateway, Prometheus, and Kiali dashboards.

Execute the Istio book info hands-on lab by deploying the book info services, configuring gateway, virtual service, and destination rules, then observe the service mesh with a live dashboard.

Troubleshoot Istio by setting up two namespaces, deploying virtual services and gateways, and inspecting request headers to diagnose how traffic routes in multitenant environments.

Explore Istio troubleshooting by executing test files, validating gateway, virtual service, and backend configurations, enabling sidecar injection, and inspecting the ingress gateway logs to resolve routing issues.

Explore real-world multitenant architectures with a real-world use case, detailing a multi-portal system: Angular SPA, ingress, microservices, and JWT-based authentication across vendor, customer, operations, and BI portals.

Build a real-world multitenant app by deploying a custom Kubernetes operator that orchestrates authentication, portals (customer, vendor, BI), and services via JWT, ingress, and custom resources in a hands-on lab.

Deploy a real-world multitenant application by building a custom kubernetes operator and provisioning custom resources to create customer and vendor portals with authentication.

Explore a hands-on lab to build a real-world multitenant portal with a custom k8s operator and Istio mesh, deploying gateways, virtual services, and destination rules.

Learn to deploy a real-world multitenant application with a custom Kubernetes operator and Istio, building custom resources, wiring sidecar injection, and monitoring traffic with Prometheus dashboards.