Basic Terraform

A minimal Terraform project that fetches live GitHub API data, applies conditional logic, and writes a local file — exercising the core HCL primitives in one coherent workflow.

Overview

This project demonstrates Terraform fundamentals — data sources, locals, conditional expressions, resources, and outputs — using a single practical example: querying the GitHub API for the hashicorp/terraform repository's star count and writing a verdict to a local file based on a popularity threshold.

Intended for engineers learning Infrastructure as Code concepts or reviewing HCL syntax for the first time.

Highlights

• Live external data — uses the http data source to call the GitHub REST API at plan/apply time, with no hardcoded values
• Conditional resource content — the written file's content is determined by a ternary expression over the fetched star count, demonstrating dynamic resource configuration
• End-to-end primitive coverage — a single ~18-line configuration exercises data source, locals, resource, and output in sequence
• Zero-auth, zero-setup — the GitHub API call is unauthenticated, requiring no tokens or credentials to run

Features

Data Fetching

• HTTP GET to the GitHub API (/repos/hashicorp/terraform) at apply time
• Response body parsed inline with jsondecode

Conditional Logic

• locals block extracts stargazers_count from the decoded response
• Ternary expression branches on a 10,000-star threshold to produce different file content

Output

• stars output variable surfaces the live count in the terminal after apply
• repo_info.txt written to the working directory with the evaluated verdict

Tech Stack

Layer	Technology	Purpose
IaC language	HashiCorp Configuration Language (HCL)	Define infrastructure declaratively
Runtime	Terraform ~> 1.10	Plan, apply, and destroy infrastructure
Provider: http	hashicorp/http ~> 3.4	Fetch data from external HTTP endpoints
Provider: local	hashicorp/local ~> 2.5	Write files to the local filesystem

Architecture

flowchart LR
A[GitHub REST API] -->|http data source| B[stargazers_count]
B --> C{over 10000 stars?}
C -->|yes| D[repo_info.txt: popular]
C -->|no| E[repo_info.txt: not popular]
B --> F[output: stars]

Loading

How It Works

1. Init — terraform init downloads the hashicorp/http and hashicorp/local provider plugins.
2. Data fetch — on terraform plan or apply, the http data source sends a GET request to https://api.github.com/repos/hashicorp/terraform.
3. Parse — a locals block decodes the JSON response body and extracts stargazers_count.
4. Branch — a conditional expression compares the count against 10,000 to select one of two strings.
5. Write — the local_file resource writes the result to repo_info.txt in the working directory.
6. Output — the stars output variable prints the raw count to the terminal.

Setup

Prerequisites

• Terraform ~> 1.10 — install guide

Run

# Download required providers
terraform init
# Preview the execution plan (no changes applied)
terraform plan
# Apply — fetch live data and write repo_info.txt
terraform apply
# Tear down managed resources
terraform destroy

Usage

After terraform apply, the terminal shows the live star count:

Outputs:
stars = 43218

And repo_info.txt in the working directory contains:

This repo is popular!

If the star count were below 10,000, the file would contain:

This repo is not as popular.

Key Decisions

Decision	Rationale	Tradeoff
Unauthenticated GitHub API call	Zero configuration needed — no tokens, no environment variables	Subject to GitHub's 60 requests/hour unauthenticated rate limit
10,000-star threshold	Round number that cleanly separates popular repos from lesser-known ones for demo purposes	Arbitrary; a real use case would parameterize this as an variable
local_file resource over output alone	Demonstrates a write-side resource, not just read/output primitives	Adds a file to the working directory that must be cleaned up with terraform destroy

About

Built to get hands-on with Terraform's core primitives — providers, data sources, locals, resources, and outputs — in a self-contained example that produces observable, real-world output without requiring cloud credentials.