GitHub Daily Developer News’ Post

Stop guessing which tool to use for Infrastructure as Code. Choose the right one for your needs. I was knee-deep in a project, balancing the complexities of multiple cloud environments. The team was split between different opinions—some swore by Terraform, others leaned towards Pulumi, and a few were advocating for AWS CDK. Each had its own merits, but which tool would truly fit our workflow? We were in a sprint when the need for a consistent and efficient IaC solution became glaring. Terraform had its strongholds with a vast community and mature ecosystem, but its HCL syntax felt cumbersome for our fast-paced dev cycles. Pulumi was attractive with its promise of using familiar programming languages, but there was some hesitation around its evolving maturity. CDK, on the other hand, seemed perfect for deep AWS integration, but the lock-in was a concern. I decided to prototype a simple infrastructure setup using each tool to explore their nuances. Contrary to my initial bias, the CDK allowed me to leverage existing TypeScript patterns seamlessly, saving us loads of time in the later stages. Terraform's plan feature was unbeatable for visualizing changes, and Pulumi's language flexibility was perfect for our developers skilled in Python. ```yaml # Sample Terraform setup provider "aws" { region = "us-west-2" } resource "aws_s3_bucket" "my_bucket" { bucket = "my-example-bucket" acl = "private" } ``` The key lesson? Match the tool to your team's strengths and project needs. CDK suited our AWS-central focus, while Terraform was unmatched for multi-cloud. Pulumi fit teams wanting to code infrastructure in their favorite language. Which one do you lean towards in your projects, and why? #DevOps #CloudComputing #Kubernetes #IaC

🛑 Stop writing 1,000 lines of static YAML. It’s 2026. For years, we loved Terraform and CloudFormation (YAML/JSON) for Infrastructure as Code (IaC). But as our architectures grew into hundreds of microservices, static config became a nightmare to maintain. Enter the AWS CDK (Cloud Development Kit). Why am I choosing CDK in 2026? It treats infrastructure as a first-class application development problem. ✅ Real Code: Use TypeScript, Python, or Go. Loops, functions, and object-oriented logic are native. ✅ Constructs: Stop reinventing the wheel. High-level CDK Constructs include embedded best practices for security and networking by default. ✅ Testing: You can unit test your infrastructure logic just like application code. The DevOps Impact: 50 lines of CDK code often replace 500 lines of raw CloudFormation YAML. 👇 Are you still team #Terraform or have you made the switch to: #AWSCDK? #AWS #CloudNative #IaC #Terraform #CDK #TypeScript #DevOpsLife

Day 2/10 — Terraform Challenge 🚀 Why Variables in Terraform? 🤔 When writing Terraform code, hardcoding values might work at the start — but it quickly becomes messy and hard to manage. This leads to: ❌ Rewriting code for small changes ❌ Difficult reuse across environments (dev, staging, prod) ❌ Poor scalability ❌ Less flexibility That’s where Variables come in 💡 Terraform variables make your code dynamic and reusable. Instead of hardcoding values, you define inputs that can be changed easily without modifying the main code. ✔ Reusable configurations ✔ Cleaner code ✔ Easy environment management ✔ Better scalability 🛠️ What I did today: Learned how to define variables Used variables.tf to store inputs Passed values using terraform.tfvars Replaced hardcoded values with variables Used outputs to display useful values 📤 What are Outputs? Outputs let you extract useful information after deployment, which you can refer to and reuse. For example: resource "local_file" "apple" {  content = var.myContent  filename = var.apple["new"] } output "local_file_path" {  value = local_file.apple.filename } -------------------- variable "apple" { type = map(string) } variable "myContent" { } -------------------- apple = { "new" = "/Users/streak2508/DevOps/Terraform/new.txt" "autonew" = "/Users/streak2508/DevOps/Terraform/autonew.txt" } myContent = "This is an apple." 💡 Biggest Learning: Hardcoding works for testing but real-world infrastructure needs flexibility. Using variables makes Terraform code reusable, scalable, and production-ready. Excited to keep building and improving 🚀 #Terraform #DevOps #AWS #InfrastructureAsCode #CloudComputing #LearningInPublic

🚀 Stop Writing YAML. Start Writing Code. Welcome to AWS CDK! If you're still managing infrastructure using long, complex YAML/JSON files in CloudFormation… you're slowing yourself down. Let’s talk about AWS CDK (Cloud Development Kit) 👇 💡 What is AWS CDK? AWS CDK lets you define your cloud infrastructure using real programming languages like: TypeScript Python Java C# Instead of writing this 👇 ❌ 500+ lines of YAML You write this 👇 ✅ Clean, reusable, testable code 🔥 Why Engineers Love CDK ✅ Faster Development Use loops, conditions, and functions — just like application code ✅ Reusable Components Create constructs and reuse across projects ✅ Type Safety Catch errors during development instead of deployment ✅ Better Collaboration Infra becomes readable for developers (not just DevOps) ⚙️ Real-World Example Instead of writing a full CloudFormation template to create an S3 bucket: const bucket = new s3.Bucket(this, 'MyBucket', { versioned: true, removalPolicy: RemovalPolicy.DESTROY, }); That’s it. CDK handles the rest. 🧠 How It Works (Under the Hood) CDK → Synthesizes → CloudFormation Template → Deploys to AWS So yes, you're still using CloudFormation — but without the pain. 🎯 When Should You Use CDK? ✔️ Microservices architecture ✔️ Multi-environment setups (dev/staging/prod) ✔️ Teams practicing DevOps / Platform Engineering ✔️ Infra that needs to evolve frequently ⚠️ When CDK Might Not Be Ideal ❌ Non-developer teams managing infra ❌ Extremely simple one-time setups ❌ Strict compliance environments needing static templates 🚀 Pro Tip Combine CDK with: CI/CD (GitHub Actions / Bitbucket Pipelines) AWS CodePipeline Monitoring (CloudWatch) You get a fully automated infra lifecycle 💬 My Take CDK bridges the gap between developers and DevOps. Infra is no longer a separate world — it's part of your codebase. 👉 Are you using CDK or still stuck in YAML land? Let’s discuss in comments! #AWS #Cloud #DevOps #InfrastructureAsCode #AWSCDK #SoftwareEngineering #PlatformEngineering

"Adopting Infrastructure as Code reduced our deployment time by 48%. Here's how I weighed the options." Choosing between Terraform, Pulumi, and AWS CDK can feel daunting. For me, it came down to their flexibility and ease of integration into existing workflows. Here's a quick look at a sample Terraform configuration snippet: ```hcl provider "aws" { region = "us-west-2" } resource "aws_instance" "example" { ami = "ami-0abcdef1234567890" instance_type = "t2.micro" } ``` I appreciated Terraform's straightforward configuration syntax, which made it easy to onboard new team members quickly. However, when I needed greater language flexibility, Pulumi’s support for multiple programming languages like TypeScript was a game changer. The AWS CDK, with its cloud-native constructs, provided deep integration with AWS services, something that was crucial for our AWS-centric projects. The ability to leverage existing code libraries sped up our iteration cycles significantly. But that's just my take. What's been your experience with these tools? Which have you found to be the most intuitive, and why? #DevOps #CloudComputing #Kubernetes #IaC

Day 19 of the #30DaysOfTerraform Challenge Today I learned something important: - Writing Terraform is the easy part. - Getting people (including yourself) to trust and adopt it is the real challenge. At the start of this challenge, my workflow looked like this: terraform apply # Check AWS console → looks fine → move on No version control for infra. No review process. No way to answer: “Who created this and why?” It worked… until it wouldn’t. The Shift Instead of trying to “fix everything,” I learned that IaC adoption is not a big bang—it's incremental. Here’s the 4-phase approach I’m now following: 🟢 Phase 1 — Start Small (Zero Risk) Create one new resource using Terraform → No migration, no risk → Just prove it works 🟡 Phase 2 — Import What Matters Bring existing infrastructure under Terraform one resource at a time → Always run terraform plan → If it’s not clean, don’t apply 🔵 Phase 3 — Build Discipline This is the hardest rule: No console changes to Terraform-managed resources Plus: PRs for every infra change terraform plan required fmt + validate in CI 🔴 Phase 4 — Automate Merge → Deploy At this point: Every change is traceable Rollbacks = git revert Infra becomes predictable The Real Lesson The biggest challenge is not technical. It’s discipline. The AWS console is: - Fast - Familiar - Always there Terraform is: - Slower upfront - Requires thinking - Forces structure But that structure is what gives you: ✅ Reproducibility ✅ Auditability ✅ Confidence My Biggest Realization Infrastructure without IaC is: Controlled chaos It works… until scale exposes the cracks. Full breakdown here: [link in first comment] #30DayTerraformChallenge #TerraformChallenge #Terraform #TerraformCloud #DevOps #IaC #AWSUserGroupKenya #EveOps

Understanding Variables in Terraform 🚀 If you’re working with Terraform and still hardcoding values… you’re missing one of its most powerful features. 👉 Variables make your infrastructure code dynamic, reusable, and production-ready. Instead of writing fixed values, you define inputs and let Terraform adapt based on environment or use case. 📌 What are Terraform variables? Variables act as inputs that allow you to customize your infrastructure without changing the core code. 💡 Why they matter: ✔ Avoid hardcoding ✔ Reuse the same code across environments (dev, staging, prod) ✔ Improve flexibility and scalability ✔ Make your code cleaner and easier to maintain 🔹 Types of variables (with examples): 👉 1. Input Variables variable "instance_type" { type = string default = "t2.micro" } 👉 2. Local Variables (locals) locals { instance_name = "my-app-server" } 👉 3. Environment Variables export TF_VAR_instance_type=t3.micro 👉 4. .tfvars File # terraform.tfvars instance_type = "t3.large" region = "us-east-1" 👉 5. Auto-loaded Variable Files (.auto.tfvars) 👈 (Often overlooked) Terraform automatically loads these files without needing CLI flags. # dev.auto.tfvars instance_type = "t2.micro" ✔ No need for -var-file ✔ Great for environment-based configs 👉 6. CLI Variables terraform apply -var="instance_type=t3.medium" 📊 Using variable in resource: resource "aws_instance" "example" { instance_type = var.instance_type } 📌 Real-world use case: Same code, different environments 👇 • Dev → t2.micro • Prod → t3.large 👉 Just change variable values, not the code. 🚀 Final takeaway: Variables are what make Terraform scalable, flexible, and production-ready. If you’re serious about DevOps, mastering variables is non-negotiable. Which type of variable do you use the most? 👇 #Terraform #DevOps #InfrastructureAsCode #CloudComputing #Automation

This is the year of the agents, I'm experimenting with some open source small project. Actually one of the question is: which is a possible control plane for my agent? The answer could be GitHub, or Azure Devops, because they are services made to orchestrate teams, and the ai agent is just another member of the team. Clearly this is a small and not-production-ready example, but I setup with very few effort, using GitHub SpecKit as a baseline. You can read some thought here. https://lnkd.in/d7b4Sxs6

Most of us use dependencies every day… but don’t always 𝘴𝘦𝘦 them 👀 While working hands-on with Terraform today, I revisited something simple but powerful: 𝗜𝗺𝗽𝗹𝗶𝗰𝗶𝘁 𝘃𝘀 𝗘𝘅𝗽𝗹𝗶𝗰𝗶𝘁 𝗗𝗲𝗽𝗲𝗻𝗱𝗲𝗻𝗰𝗶𝗲𝘀 And trust me, this small concept can make or break your infrastructure reliability. 🔹 𝗜𝗺𝗽𝗹𝗶𝗰𝗶𝘁 𝗗𝗲𝗽𝗲𝗻𝗱𝗲𝗻𝗰𝘆 (𝗔𝘂𝘁𝗼𝗺𝗮𝘁𝗶𝗰) This happens when one resource 𝘯𝘢𝘵𝘶𝘳𝘢𝘭𝘭𝘺 𝘥𝘦𝘱𝘦𝘯𝘥𝘴 on another. For example, if a storage account is using a resource group’s name, Terraform automatically understands the dependency—no need to define anything extra. ✔ Clean ✔ Less code ❌ But sometimes… too “magical” 🔹 𝗘𝘅𝗽𝗹𝗶𝗰𝗶𝘁 𝗗𝗲𝗽𝗲𝗻𝗱𝗲𝗻𝗰𝘆 (𝚍̲𝚎̲𝚙̲𝚎̲𝚗̲𝚍̲𝚜̲_̲𝚘̲𝚗̲) Here, you 𝘤𝘭𝘦𝘢𝘳𝘭𝘺 𝘵𝘦𝘭𝘭 𝘛𝘦𝘳𝘳𝘢𝘧𝘰𝘳𝘮 what depends on what. Even if there’s no direct reference, you force the order using 𝚍̲𝚎̲𝚙̲𝚎̲𝚗̲𝚍̲𝚜̲_̲𝚘̲𝚗̲. ✔ Full control ✔ No hidden surprises ✔ Better for complex or indirect relationships 💡 𝗪𝗵𝗮𝘁 𝗜 𝗼𝗯𝘀𝗲𝗿𝘃𝗲𝗱 𝘁𝗼𝗱𝗮𝘆 (𝗿𝗲𝗮𝗹 𝘀𝗰𝗲𝗻𝗮𝗿𝗶𝗼): Everything was working fine… until I introduced a small change. Terraform didn’t respect the expected order because the dependency was 𝘪𝘮𝘱𝘭𝘪𝘤𝘪𝘵 𝘢𝘯𝘥 𝘪𝘯𝘥𝘪𝘳𝘦𝘤𝘵. Result? A failed deployment 😅 Fix? Just added 𝚍̲𝚎̲𝚙̲𝚎̲𝚗̲𝚍̲𝚜̲_̲𝚘̲𝚗̲ → and everything worked perfectly. 📌 𝗠𝘆 𝘁𝗮𝗸𝗲𝗮𝘄𝗮𝘆:  • If dependency is 𝗱𝗶𝗿𝗲𝗰𝘁 → 𝗶𝗺𝗽𝗹𝗶𝗰𝗶𝘁 𝗶𝘀 𝗳𝗶𝗻𝗲  • If dependency is 𝗵𝗶𝗱𝗱𝗲𝗻 / 𝗹𝗼𝗴𝗶𝗰𝗮𝗹 → 𝗴𝗼 𝗲𝘅𝗽𝗹𝗶𝗰𝗶𝘁  • Don’t rely too much on “auto-magic” in critical infra The more I work with Terraform, the more I realize: 👉 𝘊𝘭𝘢𝘳𝘪𝘵𝘺 𝘣𝘦𝘢𝘵𝘴 𝘤𝘰𝘯𝘷𝘦𝘯𝘪𝘦𝘯𝘤𝘦. Curious—do you prefer keeping things implicit or making everything explicit in your infra code? 🤔 Learning with DevOps Insiders #Terraform #DevOps #InfrastructureAsCode #CloudEngineering #Azure #Automation #TechLearning #SoftwareEngineering #CloudComputing #LearningInPublic #IaC #DevOpsInsiders Ashish Kumar Aman Gupta

🧠 How terraform fmt Actually Works Behind the Scenes We all use terraform fmt to clean up our code… But have you ever thought about what’s happening internally? 🤔 Let’s break it down 👇 ⚙️ Working of terraform fmt When you run: terraform fmt 👉 Terraform scans all .tf files in your directory 👉 It parses them using HCL (HashiCorp Configuration Language) syntax rules 👉 Then it rewrites the code in a standard canonical format 🔍 Step-by-Step Process: 1️⃣ Parsing ➡️ Reads your Terraform code and converts it into an internal structure (AST – Abstract Syntax Tree) 2️⃣ Formatting Rules Applied ➡️ Applies predefined formatting rules like: • Proper indentation • Argument alignment • Consistent spacing • Block structure 3️⃣ Rewriting the File ➡️ The formatted version replaces the original file automatically 💡 Important Things to Know: ✔️ It does NOT change logic — only formatting ✔️ It follows HashiCorp’s official style guide ✔️ It ensures consistency across teams and projects ✔️ It is deterministic (same input → same output every time) 🧾 Example: Before: resource "azurerm_resource_group" "example"{name="rg-demo"location="East US"} After: resource "azurerm_resource_group" "example" { name = "rg-demo" location = "East US" } 🚀 Why This Matters in Real Projects? 🔹 Cleaner code reviews 🔹 Fewer merge conflicts 🔹 Better team collaboration 🔹 Easy integration with CI/CD 🧠 Pro Insight: terraform fmt is similar to tools like Prettier (JavaScript) or Black (Python) — it enforces consistency so developers can focus on logic, not styling 🔥 📣 Final Thought: If you're not using terraform fmt, you're missing out on one of the simplest productivity boosters in DevOps #Terraform #DevOps #IaC #Cloud #Automation #CodingStandards #HCL #Learning #Tech DevOps Insiders