The journey from foundational theory to a fully automated production environment is one of the most rewarding transitions in software engineering. Over my two years working in cloud infrastructure, I have come to appreciate that robust deployments are rarely born from just writing code; they stem from a deep understanding of underlying network principles and disciplined project analysis.
Recently, I completed the rigorous DevOps program at TS Academy. As I progressed through the curriculum—from advanced Bash scripting and AWS cloud assignments to my final GitOps capstone project—I kept a detailed journal to anchor my hands-on work to core operational theories. Here is how those foundational concepts directly shaped my engineering approach.
The Blueprint: Project Analysis and the DevOps Flow
Before writing a single Kubernetes manifest or CI pipeline, I relied on structured project analysis. Before any code deployment, a proper project analysis provides clarity and direction by answering fundamental questions about the systems.
I always break the application down into four critical questions:
What do we have? Identify existing components, services, databases, and dependencies with the project's architecture.
How does it run? Understand the operational procedures, deployment mechanisms, and runtime environment of the application.
What must be configured? Document all necessary configurations, environment variables, and secrets required for the application's functionality.
How do we test it works? Define the testing strategies, validation steps, and performance benchmarks to ensure proper functionality before release.
This analysis feeds into a strict, five-stage DevOps flow: Understand, Run locally, Automate, Deploy, and Scale.
The critical first phase is the local environment setup and project analysis. You must systematically validate each tier:
Database: Ensure proper database schemas, data integrity, and connection configurations for seamless development and testing.
Backend: Provide a stable local runtime environment for backend services, enabling accurate debugging and API integration.
Frontend: Guarantee consistent local UI builds and allow developers to interact with the application as it will appear in production.
End-to-End Flow: Facilitate a holistic local environment where the entire application stack can be tested for complete functional integrity.
Networking Theory Meets Reality
Whether you are deploying to AWS or Kubernetes, traditional networking concepts always apply. Classless Inter-Domain Routing (CIDR) is the fundamental practice of dividing a large IP network into multiple smaller, more efficient, and manageable subnetworks. A /16 CIDR block is significantly larger, providing 65,536 addresses, and is typically used for large data centers or VPCs. Conversely, a /24 CIDR block provides 256 addresses and is often used for smaller subnets like local area LANs or development environments.
Understanding how routing directs data packets from their source to their destination across interconnected networks allows information to flow seamlessly across the internet and private networks. Similarly, DNS translates human-readable domain names into machine-readable IP addresses, while also handling reverse lookups, caching frequently accessed DNS records locally, and traffic balancing.
When troubleshooting routing, I rely on classic command-line tools:
Ping: Tests the reachability of a host on an IP network and measures the round-trip time.
Traceroute: Displays the route and measures transit delays of packets across an IP network.
Netstat: Displays network connections (both incoming and outgoing), routing tables, and interface statistics.
NMAP: A free and open-source network scanner used for network discovery and security auditing.
TCPDUMP: Intercepts and displays TCP/IP and other packets being transmitted or received over a network.
AWS Architecture & Production Databases
I solidified these foundations by architecting a classic 3-tier AWS deployment.
For the data tier, the best service used for the database is RDS (Relational Database Service) to reduce operational overheads, minimize manual control, and ensure reliability. Crucially, there are strict requirements for production databases:
Private: Never expose your database directly to the public internet; it must reside in private subnets accessible only by authorized services within your network. The RDS database stores the app's data and is completely isolated from the public internet, only accepting traffic from the backend.
Backed UP: Implement regular, automated backups with a clear recovery strategy, and test your backups to ensure they can be restored successfully in a disaster scenario.
Access-Controlled: Enforce strict access controls (e.g., IAM policies and security groups) ensuring only necessary apps and personnel can connect. The RDS security group must be strictly configured to reject public access and only permit incoming traffic from the backend EC2.
For the frontend tier, using S3 for static hosting is the industry standard because it eliminates the need to provision, manage, or patch servers, which simplifies operations and reduces maintenance overhead. S3 scales automatically for massive scale effortlessly, is cost-effective, and secure by design. CloudFront sits in front of S3 to serve the frontend globally via a secure HTTPS domain.
The connection flow is simple: When a user visits the CloudFront domain, the frontend loads in their browser and sends API requests directly to the backend's EC2 public IP address on port 5000.
Troubleshooting 101: The DevOps Mindset
One of the most valuable lessons I journaled during this program was a shift in troubleshooting philosophy. You don't have to be a Python backend expert to troubleshoot a Python app.
DevOps engineers read code looking for patterns and infrastructure hooks, not business logic. No matter the language the app is written in, they all connect to infrastructure the exact way: they all need a port to listen on, an IP address, and a connection setup or string.
So when an app won't connect, you don't have to read the file; just use grep to search for "localhost, 127.0.0.1, Port, DB_Host" to find the hardcoded value. Finding and replacing these hardcoded values with dynamic environment variables is the key to successfully containerizing and orchestrating applications.
Culmination: The GitOps & K3s Capstone
This rigorous understanding of ports, routing, and infrastructure hooks seamlessly transitioned into my final capstone project: deploying the "Team Task Manager" using a modern GitOps workflow.
Taking the principles I learned from networking and AWS assignments, I moved away from manual EC2 configurations and utilized declarative YAML manifests on a K3s Kubernetes cluster. I engineered automated CI/CD pipelines using GitHub Actions to push Docker artifacts directly to GHCR, while Argo CD actively monitored the repository to synchronize the cluster state in real time.
Bridging the gap between raw theories like using grep for port hunting and securing private database subnets with modern tools like Argo CD and K3s has been an incredible milestone in my engineering career. Here’s to the next challenge! 🥂
Top comments (0)