Applied
Engineering
Results
samuel-torres.com
Role
Containerizing an application and deploying it on Kubernetes end-to-end, from Docker image to a running, autoscaling cluster — a personal project.
Core stack
Kubernetes · Docker · YAML · Horizontal Pod Autoscaler · Minikube · ConfigMap · Ingress
Code
What it is
Taking a containerized application past "it runs on my machine" into a reproducible, declarative deployment. Instead of starting containers by hand with docker run, the whole desired state — how many replicas should run, how they're configured, how traffic reaches them, how they scale — is written down as Kubernetes manifests and applied to a cluster.
How it's built
- Application packaged as a Docker image, versioned and pulled by the cluster rather than built in place.
- Deployment manifest defining the desired replica count and update strategy, so Kubernetes — not a manual script — keeps the running state matching what's declared.
- Service and Ingress manifests handling internal routing and external access, instead of exposing pods directly.
- Configuration externalized into a ConfigMap, so the same image can run with different settings instead of baking config into it.
- A Horizontal Pod Autoscaler (HPA) watching CPU utilization and adjusting replica count within a defined range.
- Everything tested locally on Minikube before treating the manifests as done — a manifest that only "looks right" doesn't count until it has actually reconciled on a real cluster.
Design notes
Environment-specific values sit in a ConfigMap, not hardcoded into the Docker image. The same image can move between environments without a rebuild.
Routing is centralized at the Ingress layer rather than opening a NodePort per service — one entry point, one place to reason about how traffic gets in.
The HPA is given a min/max replica range and a CPU target, not a single fixed replica count — the cluster decides where in that range to sit based on actual load.
Short version (portfolio card)
A Dockerized application deployed on Kubernetes with hand-written manifests: Deployment, Service, Ingress, ConfigMap and a Horizontal Pod Autoscaler, tested end-to-end on Minikube.
Resume / LinkedIn bullets
- Containerized an application with Docker and deployed it to Kubernetes using hand-written Deployment, Service, Ingress and ConfigMap manifests.
- Configured Horizontal Pod Autoscaling based on CPU utilization thresholds.
- Validated the full manifest set end-to-end on a local Minikube cluster before considering the setup complete.