Hands-On DevOps: Build Real Projects for Your Portfolio

Explore how a flight booking app lets users sign up, search flights from California to Utah, buy tickets, and delete them using a simulated payment flow and ticket IDs.

Set up a Postgres database in a docker container, bind port 5432, and use pg admin to create states, flights, tickets, and users tables with primary keys and not-null constraints.

Insert and generate flights by cross joining the states table to populate the flights table with departure and arrival states, random departure and arrival times, and prices.

Swap arrival and departure times in the flights table for records where departure is later than arrival, using a short sql query, then verify flights depart before arriving.

Build a Flask server connected to Postgres with a templates-based sign-up page and a form posting username, password, and email to /shop on port 5000.

Learn to style a sign-up page with a css file by creating body and container classes, configuring colors, spacing, inputs, labels, and a submit button using a flex layout.

Create a sign-in page by configuring a sign-in route with get and post methods, rendering sign-in HTML, and aligning its design with the sign-up page.

Create a shop page that directs users after sign up or sign in via post route. Implement buy and delete ticket forms, with a session username and shop.html rendering.

Create and configure the tickets page to help users buy a flight ticket, including flight data retrieval, time formatting with DateTime, and rendering ticket.html with a payment route.

Add a post payment route to capture flight data from the form into session variables, then render a payment page with name on card, card number, expiration, and cv.

Create a successful ticket purchase confirmation page by generating a 10-character ticket id with random and string, inserting the ticket into the tickets table, and rendering the confirmation with id.

Add existing flights feature enables signed-in users to view their purchased tickets on the shop page, displaying a flights table with departure, destination, and times.

Implement a delete ticket flow by accepting departure and destination inputs, querying the tickets table, and presenting a delete form with a ticket id to remove the ticket.

Create a post route to delete a ticket from the database, validating the ticket id against session data (destination and departure). Delete, commit, and render a success or error page.

Build a Docker image for the app, push to Docker Hub, and use environment variables for Postgres credentials, updating the Dockerfile to install dependencies and expose the port.

Create a standard GKE cluster in Google Cloud by configuring a demo cluster with a single default node, enabling autoscaler (0–5 nodes) and using the default VPC in zonal settings.

Set up a Postgres instance in a Kubernetes cluster by creating a Postgres stateful set and service, secured with the creds secret and a volume claim.

Automate the creation of postgres tables and data with a Kubernetes job that runs an init sql script from a configmap, using secrets for authentication and readiness checks.

Learn to create Flask app resources on Kubernetes, including deployment and service, configure Postgres connection via secrets, and apply yaml manifests with kubectl to run and verify pods.

Expose your Kubernetes app by installing cert-manager and the Nginx ingress controller with Helm charts, enabling automated certificates and secure https access.

Purchase and configure a domain using GoDaddy, set up cloud dns zones, and create records to route traffic to a static ip for a load-balanced app.

Explore DNS propagation, its speed factors like TTL and ISP caching, and accelerate updates by lowering TTL, flushing caches, using Google Public DNS, and testing the setup.

Explore cert manager issues certificates using Let's Encrypt, creates an issuer, and handles dns-01 challenges with cloud dns and a service account.

Deploy and expose your app with an ingress resource, configure a public host and tls via cert manager, update domain references, and deploy a new image to the cluster.

Discover terraform, a HashiCorp tool, and how it enables infrastructure as code with a high level configuration language (hca). Learn write, plan, apply, and destroy workflow and state management.

initialize terraform and set up a google cloud project by creating a service account, downloading a key, and configuring a gcs backend to store the tf state.

Create a gke cluster with Terraform, including a demo cluster and node pool, private endpoint configurations, maintenance windows, and autoscaling.

Terraform creates a static ip and a cloud dns zone. Map an ingress domain to ip using Google Compute Address, Google DNS managed zone, and Google DNS record set.

Explore GitHub actions, a CICD platform that automates workflows in your repository, and learn to initialize git, push code to GitHub, and configure workflows with yaml in the .github/workflows directory.

Configure a GitHub Actions workflow to automate Terraform init, plan, and apply, build and push Docker images, and deploy to GKE, triggered by pushes to the main branch.

Configure and test the Docker phase of a GitHub Actions workflow, authenticate to Docker Hub, build and push the image, and verify infrastructure via Terraform in a cohesive DevOps pipeline.

Deploy Kubernetes resources to a GKE cluster by authenticating with Google Cloud, configuring gcloud, installing kubectl and helm, and applying resources via GitHub Actions.

Install helm charts for nginx ingress and cert-manager, create a GCP service account with dns admin rights, generate secrets for postgres and dns resolver, then deploy Kubernetes resources.

Test a complete GitHub Actions pipeline that builds and pushes a Docker image to Docker Hub, then deploys a Google Cloud Kubernetes app that runs on the internet.

Explore building a multi-environment cloud platform using Terraform, Helm, and Kubernetes, provisioning VPCs, Kubernetes clusters, secret management, and monitoring with Prometheus and Grafana, plus Mongo Express and MongoDB deployments.

Explore the final app UI across environments, showing Mongo Express for database management, Prometheus for metrics, and Grafana for exploring metrics across QA and production.

Build a Terraform network module to create a Google Compute Network and subnetwork, and test resources. Plan multi-environment deployments with modules, later helm charts, and configuring Prometheus and Grafana.

Configure a google compute router and nat to give private Kubernetes nodes access to public registries, enabling kubelet to pull images like MongoDB, Prometheus, and Grafana.

Explore adding a Google Kubernetes Engine cluster in a Terraform module, configure private nodes, master cidr, pod and service ip ranges, and logging, and wire outputs for the GKE setup.

Add a node pool to the module by configuring the Google container resource, binding to the cluster, and setting autoscaling, upgrade, and auto repair options plus node config defaults.

Export kubernetes control plane logs (api server, scheduler, controller manager) to google cloud storage via sinks and buckets. Use terraform for each to configure filters, retention, and service account permissions.

Apply the GKE module with Terraform to create resources, assign the service account logging admin and project IAM admin roles, and verify log export to cloud storage.

Learn to automate secrets with Google Cloud Secret Manager and Kubernetes using workload identity on GKE, Terraform, and the External Secrets helm chart.

Create a secret manager in terraform, generate a secure password with the random provider, set user managed replication by region, and bind access via workload identity to kubernetes secrets.

Learn to automate Kubernetes secret creation by wiring an external secrets helm chart to Google Cloud Secret Manager, using cluster secret store and external secret resources.

Add a DNS module to bind DNS records to ingress and static IPs to load balancers, using a single DNS zone across the QA, production, and monitoring environments.

Advance hands on devops by building environments with Terraform: create modular networks and a GKE cluster, expose outputs for other configurations, and configure secret manager, dns, and environment bindings.

Build production and monitoring environments with Terraform by duplicating configurations, adjusting network and GKE settings, enabling autoscaling, secrets management, and DNS, then deploy and verify in the cloud UI.

Configure the production secret manager service account with the secret access role for the Secret Manager API in the production environment, using Terraform plan and apply to implement changes.

Explore how Helm serves as a Kubernetes package manager, creating and deploying charts with templates and values.yaml, managing repositories, releases, versioning, upgrades, and rollbacks across environments.

Configure a Helm chart for Mongo Express by defining deployment, service, and HPA, binding the release namespace, and tuning replicas and revision history limit.

Configure Mongo Express in Kubernetes by setting readiness and liveness probes, allocating resources, exposing a service on port 27017, and configuring service selectors for a complete DevOps workflow.

Create a horizontal pod autoscaler for a Mongo Express deployment in Kubernetes, configuring the scale target, min/max replicas, CPU utilization metrics, and scale up/down policies with helm values.

Observe how the HPA scales a PHP Apache deployment based on CPU usage, creating multiple pods while using kubectl and minikube to demonstrate autoscaling.

Configure a MongoDB Kubernetes stateful set with YAML, enabling ordinals start at one and parallel pod management. Run three replicas with rolling updates and PVC retention decisions.

Configure volume mounts and volume claim templates for MongoDB data in a stateful set, and enable autoscaling on port 27017 with min 3, max 10.

Add an ingress to the helm chart, validate with helm lint and template, fix yaml issues, and configure dynamic ingress annotations and tls using values.

Explore implementing a pod disruption budget (PDB) in Helm and Kubernetes, covering voluntary and involuntary disruptions, with min available and max unavailable settings.

Install the External Secrets Helm chart as a dependency, configure namespace and service accounts, create a cluster secret store and external secret, and deploy the app to the QA environment.

Deploys the app to production by configuring domain, production secret, and service account, then installing helm charts and external secrets to recreate the application across environments.

Install and configure the networking chart to manage cluster networking with ingress nginx controller and cert-manager, set up workload identity and dns bindings to expose the ingress.

Apply production network configuration with Terraform and Helm, adding service accounts, DNS, and a cert-manager cluster issuer to deploy and secure the production application.

Add the networking chart to the monitoring cluster, configure cert-manager, a load balancer, and ingress for Grafana, then apply Terraform and Helm changes to expose metrics centrally.

Explore Prometheus, the open source monitoring and alerting toolkit, using time series data and PromQL to query metrics from endpoints across instances and jobs with alerting and service discovery.

Explore the Prometheus web UI to view metrics and scraped targets on a minikube setup. Install Prometheus via helm, deploy node exporter and kube-state-metrics, and run API server request queries.

Add eight A records for the QA and production environments to support dual ingresses for Prometheus and the application, using Terraform outputs to reference the load balancer IP.

Set up a multi-environment monitoring stack by adding Prometheus with ingress and TLS for production and the Kiwi environment, and visualize metrics via Grafana across all environments.

Deploy the monitoring chart to the qa environment, configure alert manager address and port 9093, install in the monitoring namespace with helm, and verify Prometheus metrics.

Deploy a Prometheus monitoring chart to the production cluster by editing the values file, creating a monitoring namespace, installing with Helm, and verifying pod status, ingress, and scraped targets.

Deploy Grafana and Prometheus in the monitoring environment to centralize metrics from QA, production, and monitoring Prometheus instances, configure data sources, and verify connections.

Explore options to ensure data is replicated across MongoDB instances, comparing a single replica versus multi-instance replication, and learn how to keep databases in sync with Mongo Express.

Understand how MongoDB replica sets achieve redundancy and high availability by replicating data from a primary to secondaries, with elections to elect a new primary.

Configure MongoDB as a replica set in Kubernetes using a headless service, set service names and env vars, and run a bootstrap job to initiate replica set across three pods.

Configure Kubernetes core components with Terraform and kubeadm, set up a webhook-based authentication against a cloud SQL Postgres database, and build a Python-based custom controller and API server workflow.

Explore the Kubernetes API server, its core components, and add-ons like CoreDNS and CNI, then map the authentication, authorization, and persistence flow.

Learn to build a custom Google VPC with Terraform, disable auto subnet creation, configure firewall policy order, and create an IPv4 subnetwork in us-central1 linked to the network.

Create four Google service accounts for four virtual machines and assign an external IP address to each, using a list of instance names to set account IDs and display names.

Configure cloud sql with private ip to securely connect your vpc to Google Cloud SQL instances (Postgres) using private services access and Terraform resources.

Create a Google Compute global address, configure an internal private IP with a 16 prefix for VPC peering, and set up a service networking connection with a random Postgres password.

Configure a cloud sql Postgres 15 instance with Terraform, enabling private networking and private IP, regional high availability, backups, and controlled disk, maintenance, and deletion settings.

Configure google compute instances with terraform, create two vms with e2 standard-2 dependent on the scale database, set up ssh keys, startup scripts, service accounts, and a static address.

Demonstrates loading role-specific startup scripts on each virtual machine using the index, guiding which setup script to run (webhook, master, or machine) based on the instance name.

Configure two google compute firewall rules for a subnetwork: an ingress rule for intra-subnetwork traffic and an ssh rule on port 22, using for_each and firewall objects.

Write a bash script with a shebang to install kubectl and the Postgres client, and configure the webhook script to set up Python, Flask, and cycle PG two for Postgres.

Explore the Open Container Initiative (OCI) and its standards for container runtimes, images, and distributions, ensuring portability and interoperability across Docker Hub and AWS ECR.

Learn the CRI-O container runtime architecture, its image and runtime services, gRPC communication with Kubelet, OCI runtime using runC, container root filesystem creation, and CNI networking for pods.

Create setup master and setup node bash scripts by following the Cryer documentation, install debian packages and kubernetes and cri-o repositories, install kubeadm, kubectl, and crio, and bootstrap the cluster.

Implement a webhook server for Kubernetes authentication by parsing credentials from requests and validating them against a Postgres database with psycopg2, using a test token to verify flow.

Build a Flask-based webhook server that accepts post requests, parses json payload to extract a token, authenticates with a database, and returns a structured authentication result.

Use terraform provisioners to run remote exec scripts on a web server VM after creation, exporting a postgres password as an environment variable via SSH.

Apply Terraform resources to provision a Google SQL database, resolve a 400 error by selecting a db-f1-micro tier, then observe resource creation and completion.

Test and validate a webhook server by sending a token review via curl from a virtual machine, verifying it queries the cloud SQL database and returns authentication status.

Discover how Kubeadm bootstraps a Kubernetes cluster by initializing the control plane, generating certificates and kubeconfigs, and enabling static pods managed by the kubelet for scaling.

Learn to configure cube adm init with a yaml config, including node registration and local api endpoint, with multiple config types separated by triple dashes, taints, and cri socket.

Configure the API server to talk to the webhook server using a kube config with clusters, contexts, and users. Follow the token review flow that returns authenticated true or false.

Configure a kubeconfig yaml to enable the api server to reach the webhook server by defining a cluster, user, and context, using http and port 5000, with certificate validation skipped.

Configure the API server to integrate the authentication flow with a token webhook, and set cluster version 130, image repository registry.kubernetes.io, and cluster name control plane.

Test the full authentication flow from a client to the API server and webhook, initialize a kubeadm cluster, configure admin and user credentials, and validate authorization with kubectl.

Join the worker node to the control plane with kubeadm join, then install Calico CNI to ready the cluster and verify core DNS and kube-proxy pods are running.

Explore admission controllers in Kubernetes: these components intercept requests after authentication and authorization, enforcing mutating and validating checks on create, delete, or modify operations.

Discover how the pod security admission controller enforces pod security context and privilege levels, host namespaces and privilege escalation, across baseline, privileged, and restricted policies with enforce and audit modes.

configure the pod security admission controller and integrate it with the API server by using a pod security yaml file, enable the admission plugin, and apply enforce and warn modes.

Configure the api server with pod security admission flags and a config mount, then test a host-network, privileged pod to verify the pod security admission controller blocks violations.

Discover how the kube scheduler, Kubernetes’ default control-plane scheduler, filters and scores nodes to place unbound pods on the best feasible node, using scheduling profiles and extension points.

Configure the cube scheduler for your cluster by creating scheduler.yaml, specifying the api version and client connection, and mounting it into the scheduler pod via the unity yaml.

Test a custom scheduler by adding a worker node, scheduling a pod with the custom profile, and reviewing scheduler logs to see how node scores drive placement.

Explore the Kubernetes controller manager and per-resource controllers. See how control loops move the current state toward the desired state, with examples like job controller and building a custom controller.

Configure the controller manager to coordinate deployment, replica set, and stateful set controllers, adjust concurrent sync flags, and apply changes via the kube controller manager YAML.

Explore custom resources and CRDs in Kubernetes and learn how a custom controller and operators automate cloud resources, such as Cloud SQL instances, with Python.

Define a custom resource definition in Kubernetes, specifying apiVersion v1, group sql.gcp, and an OpenAPI v3 schema for a cloud sql instance with name, instance tier, and db version.

Create a custom resource from a custom resource definition by specifying api version, kind, metadata, and a spec with name, instance, tier, and db version, then apply with kubectl.

Start building a custom controller by scaffolding a Python file, importing libraries, configuring credentials, and implementing a root password generator for Cloud SQL, plus local testing.

Create and delete Google Cloud SQL instances via custom resources, configuring name, instance tier, db version, region, private networking, and root password generation with logging of operations and errors.

Test creating and deleting a cloud sql instance with the custom controller, verify private IP access from the cluster, and confirm postgres connectivity via telnet.

Prepare a cluster deployment by adding Cop-based event wrappers, implement create and delete handlers, and build a docker image for the controller to manage Google Cloud SQL instances.

Create a Google Cloud service account with Cloud SQL API access, generate a key, store it as a Kubernetes secret, and mount it into the controller pod.

Deploy and test a Kubernetes operator by creating a cluster role and binding a service account, applying resources.yaml to provision a Cloud SQL instance, and verifying logs and pod accessibility.