Real‑World DevOps & CI/CD Project: Migrate a Quiz App to K8s

In this lecture, we build the initial VM-based architecture on AWS that will later be migrated to Kubernetes.

You will create separate database and application servers, configure basic networking, and understand why this separation matters in real-world deployments. Instead of blindly launching instances, we focus on purpose-driven infrastructure—what runs where, and why.

This lecture establishes the baseline architecture: a traditional setup many teams still run in production. You’ll see how applications connect to a database over the network, how credentials are handled, and what operational limitations exist in this model.

By the end of this lecture, you will have a fully functional DB server and application server on AWS, forming the reference point for the Kubernetes migration that follows. This clarity is essential—you can’t modernize what you don’t fully understand.

This lecture sets the stage for the DevOps journey: from VM-based infrastructure to containerized, cloud-native systems.

In this lecture, we install and configure MySQL on an AWS-based database server. You’ll set up the database service, verify connectivity from the application server, and prepare the data layer for real application usage.

This step establishes a stateful backend that will later be migrated into containers and Kubernetes, making it a critical foundation for the DevOps workflow that follows.

In this lecture, we configure the MySQL database for application usage by creating the required database, users, and permissions. You’ll connect the application to MySQL, validate data flow, and ensure the setup mirrors a real production environment.

This configuration becomes the reference state for the later migration to containers and Kubernetes.

In this lecture, we configure the application to connect with the database using proper connection settings. You’ll validate end-to-end communication, handle configuration values correctly, and confirm the application works as expected with the backend database.

This step completes the VM-based setup and prepares the application for containerization and Kubernetes deployment.

In this lecture, we create a systemd service for the application to ensure it runs reliably as a managed background process. You’ll configure startup behavior, handle restarts, and verify the application survives reboots.

This step reflects how applications are operated on traditional servers and sets a clean baseline before moving to containers and Kubernetes.

In this lecture, we write a Dockerfile for the MySQL database and build a custom database image. You’ll understand how database configuration, initialization, and data handling are defined inside a container.

This step prepares the database for consistent, repeatable deployments using containers.

In this lecture, we tag and push the MySQL container image to Docker Hub. You’ll understand image versioning, repository structure, and how container images are shared and reused across environments.

This makes the database image available for deployment in automated workflows.

In this lecture, we create a local Kubernetes cluster using Kind. You’ll set up the cluster, verify node status, and ensure the environment is ready for deploying containerized applications.

This provides a fast and reliable Kubernetes setup for hands-on experimentation and testing.