Forem: Kamal Rhrabla

Terraform Modules for Reusable GCP Infrastructure (With a Real VPC Module Example)

Kamal Rhrabla — Sat, 18 Apr 2026 19:01:16 +0000

Terraform modules are the best way to stop copy/pasting infrastructure code across projects and environments. Instead of rewriting the same VPC, subnets, firewall rules, and settings over and over, you wrap that logic in a module and reuse it with clean inputs/outputs.

This post shows:

What a module is (in practice)
How to structure modules in a repo
How to write a reusable GCP VPC module
How to call it for dev and prod
Common module mistakes (and how to avoid them)

What is a Terraform module?

A Terraform module is just a folder containing Terraform files (.tf) that expose:

inputs (variables.tf)
outputs (outputs.tf)
resources (main.tf, etc.)

You can call a module multiple times with different parameters, like:

module "network_dev" {
  source     = "../modules/vpc"
  project_id = "my-dev-project"
  vpc_name   = "dev-vpc"
}

Recommended repository structure

Here’s a clean layout that works well for real teams:

terraform/
  modules/
    vpc/
      main.tf
      variables.tf
      outputs.tf
      versions.tf
      README.md
  envs/
    dev/
      main.tf
      providers.tf
      backend.tf
      terraform.tfvars
    prod/
      main.tf
      providers.tf
      backend.tf
      terraform.tfvars

Idea: keep modules generic and environments thin.

Module example: a reusable GCP VPC module

This VPC module will create:

1 VPC network
N subnets (from a list)
Optional firewall rules (basic example)

`modules/vpc/versions.tf`

terraform {
  required_version = ">= 1.5.0"

  required_providers {
    google = {
      source  = "hashicorp/google"
      version = ">= 5.0.0"
    }
  }
}

`modules/vpc/variables.tf`

variable "project_id" {
  description = "GCP project ID where resources will be created."
  type        = string
}

variable "vpc_name" {
  description = "Name of the VPC."
  type        = string
}

variable "routing_mode" {
  description = "VPC routing mode: REGIONAL or GLOBAL."
  type        = string
  default     = "REGIONAL"

  validation {
    condition     = contains(["REGIONAL", "GLOBAL"], var.routing_mode)
    error_message = "routing_mode must be REGIONAL or GLOBAL."
  }
}

variable "subnets" {
  description = <<EOT
List of subnets to create.

Example:
[
  { name="public-us-central1", region="us-central1", cidr="10.10.0.0/24", private_google_access=true },
  { name="private-us-central1", region="us-central1", cidr="10.10.1.0/24", private_google_access=true }
]
EOT

  type = list(object({
    name                  = string
    region                = string
    cidr                  = string
    private_google_access = bool
  }))
}

variable "firewall_rules" {
  description = <<EOT
Optional firewall rules.
Keep it simple: allow protocol/ports from source ranges to target tags.
EOT

  type = list(object({
    name          = string
    direction     = optional(string, "INGRESS")
    priority      = optional(number, 1000)
    source_ranges = list(string)
    target_tags   = list(string)
    protocol      = string
    ports         = list(string)
  }))

  default = []
}

`modules/vpc/main.tf`

resource "google_compute_network" "this" {
  project                 = var.project_id
  name                    = var.vpc_name
  auto_create_subnetworks = false
  routing_mode            = var.routing_mode
}

resource "google_compute_subnetwork" "this" {
  for_each = { for s in var.subnets : s.name => s }

  project                  = var.project_id
  name                     = each.value.name
  ip_cidr_range            = each.value.cidr
  region                   = each.value.region
  network                  = google_compute_network.this.id
  private_ip_google_access = each.value.private_google_access
}

resource "google_compute_firewall" "this" {
  for_each = { for r in var.firewall_rules : r.name => r }

  project     = var.project_id
  name        = each.value.name
  network     = google_compute_network.this.name
  direction   = each.value.direction
  priority    = each.value.priority
  target_tags = each.value.target_tags

  source_ranges = each.value.source_ranges

  allow {
    protocol = each.value.protocol
    ports    = each.value.ports
  }
}

`modules/vpc/outputs.tf`

output "network_id" {
  description = "The ID of the VPC network."
  value       = google_compute_network.this.id
}

output "network_name" {
  description = "The name of the VPC network."
  value       = google_compute_network.this.name
}

output "subnet_ids" {
  description = "Subnet IDs keyed by subnet name."
  value       = { for k, s in google_compute_subnetwork.this : k => s.id }
}

Using the module: dev environment example

`envs/dev/main.tf`

module "vpc" {
  source     = "../../modules/vpc"
  project_id = var.project_id
  vpc_name   = "dev-vpc"

  subnets = [
    {
      name                  = "dev-us-central1-public"
      region                = "us-central1"
      cidr                  = "10.10.0.0/24"
      private_google_access = true
    },
    {
      name                  = "dev-us-central1-private"
      region                = "us-central1"
      cidr                  = "10.10.1.0/24"
      private_google_access = true
    }
  ]

  firewall_rules = [
    {
      name          = "dev-allow-ssh-from-office"
      source_ranges = ["203.0.113.10/32"]
      target_tags   = ["ssh"]
      protocol      = "tcp"
      ports         = ["22"]
    }
  ]
}

`envs/dev/variables.tf`

variable "project_id" {
  type        = string
  description = "Dev project ID"
}

Module tips (this is what saves you later)

1) Keep modules “dumb” and input-driven

Avoid hardcoding:

regions
CIDRs
environment names
project IDs

2) Prefer composable small modules

Instead of a huge “platform module”, consider:

modules/vpc
modules/cloud_run
modules/cloud_sql
modules/iam

Then compose them per environment.

3) Be careful with IAM resources

Some IAM resources are authoritative and can remove access unexpectedly.
When in doubt, start with *_iam_member resources and grow from there.

4) Version your modules

If you publish modules (Git tags), you can pin versions:

module "vpc" {
  source = "git::https://github.com/YOUR_ORG/YOUR_REPO.git//modules/vpc?ref=v1.0.0"
}

Wrap-up

Terraform modules turn your GCP infrastructure into reusable building blocks:

less duplication
safer changes
consistent environments

Getting Started with Google Cloud Platform (GCP): A Practical Guide for Developers

Kamal Rhrabla — Thu, 09 Apr 2026 22:08:22 +0000

Google Cloud Platform (GCP) is Google’s suite of cloud services for building, deploying, and operating applications at scale. If you’ve used AWS or Azure, GCP will feel familiar but it also has some “Google-native” strengths like BigQuery, first-class Kubernetes support, and strong data/ML tooling.

This post is a developer-focused introduction: what GCP is great at, the core services you should know, and a simple path to start shipping real projects.

Why use GCP?

GCP is a strong choice if you care about:

Managed compute that scales cleanly (especially serverless)
Containers + Kubernetes (Google created Kubernetes)
Data workloads (analytics, warehousing, streaming)
Machine learning tooling (MLOps, training, model hosting)
Global infrastructure + networking

It’s also easy to start small (serverless) and grow into more complex architecture only when you need it.

The mental model: how GCP is organized

Before jumping into services, it helps to know the hierarchy:

Organization (company/domain; optional for personal projects)
Folders (optional grouping)
Projects (the main unit for billing, IAM, and resources)
Resources (VMs, buckets, databases, etc.)

For most developers, a Project is where everything begins.

Tip: Use separate projects for dev, staging, and prod if you can especially once billing and IAM start to matter.

Core GCP services developers should know

1) Compute (where your code runs)

Cloud Run: Run containers without managing servers. Great default for APIs, web apps, and workers.
App Engine: PaaS-style deploys (less common in brand-new systems, but still used).
Compute Engine: Virtual machines (full control).
GKE (Google Kubernetes Engine): Managed Kubernetes for orchestration at scale.

Rule of thumb:

If you can containerize it → start with Cloud Run
If you need orchestration across many services → consider GKE
If you need low-level control → use Compute Engine

2) Storage (files and blobs)

Cloud Storage: Object storage for uploads, artifacts, backups, media, static assets.

Good use cases:

User uploads (images/video)
Build artifacts (zips, containers metadata)
Data exports/imports
Static website assets behind CDN

3) Databases (store application data)

Cloud SQL: Managed PostgreSQL / MySQL / SQL Server.
Firestore: NoSQL document database (great for event-driven/mobile/web apps).
Spanner: Globally distributed relational DB (powerful, enterprise-grade).

If you’re building a typical web backend, Cloud SQL (Postgres) is a great starting point.

4) Messaging + async workloads

Pub/Sub: Event streaming and messaging.
Cloud Tasks: Managed task queues (great for background jobs triggered by HTTP).

A common “serverless backbone” looks like:

Cloud Run (API) → Pub/Sub (events) → Cloud Run (worker)

5) IAM (permissions)

IAM controls who can do what.

Prefer least privilege over broad admin access
Use service accounts for apps and automation
Avoid giving everyone Owner (it’s convenient and also risky)

IAM feels annoying until it saves you from accidental production changes or surprise bills.

A practical starter architecture (small, modern, scalable)

If you want a “default” GCP stack for a new product:

Cloud Run for your API (containerized)
Cloud SQL (Postgres) for relational data
Cloud Storage for file uploads
Secret Manager for secrets (DB passwords, API keys)
Cloud Logging + Error Reporting for observability
Cloud Build for CI/CD (optional, but very handy)

This setup is production-friendly without forcing you to operate servers.

Getting hands-on: a simple path to ship something

Here’s a practical 30–60 minute plan:

Create a GCP project
Enable billing (many services require it)
Install the Google Cloud SDK (gcloud)
Deploy a small container to Cloud Run
Add Cloud SQL only after your service is deployed and reachable

The key is momentum: deploy something tiny first, then iterate.

Common mistakes (and how to avoid them)

Using Owner everywhere → create scoped roles/service accounts.
Mixing regions randomly → pick a region near your users and keep services aligned.
No budgets/alerts → set a budget alert on day one.
Starting with Kubernetes too early → Cloud Run often covers your needs for a long time.

When GCP really shines

GCP is especially strong for:

Analytics-heavy products (BigQuery is a standout)
Event-driven systems (Pub/Sub + Cloud Run)
Kubernetes-based platforms (GKE + ecosystem)
ML workflows (Vertex AI + data tooling)

Conclusion

You don’t need to learn all of GCP to be productive. Pick a small core:
Cloud Run + Cloud SQL + Cloud Storage + IAM + Logging, and you can ship real services quickly.

Getting Started with gRPC in Go (Golang): A Practical Guide

Kamal Rhrabla — Thu, 26 Mar 2026 21:25:26 +0000

Modern applications are moving toward microservices and high-performance communication. If you're still using REST for everything, it might be time to explore a faster and more efficient alternative: gRPC.

In this article, we’ll break down what gRPC is, why it’s powerful, and how to build your first service using Golang.

What is gRPC?

gRPC (Google Remote Procedure Call) is a high-performance RPC framework developed by Google. It allows services to communicate directly using function calls instead of traditional HTTP/JSON APIs.

Instead of:

GET /users/1

You do:

userService.GetUser(ctx, &UserRequest{Id: 1})

Why Use gRPC?

1. High Performance

Uses HTTP/2
Binary serialization with Protocol Buffers (Protobuf)
Faster and more efficient than REST/JSON

2. Strongly Typed APIs

Contracts are defined using .proto files
No ambiguity between services

3. Streaming Support

Client streaming
Server streaming
Bidirectional streaming

Perfect for real-time systems (chat apps, live data, etc.)

4. Multi-language Support

Works with Go, JavaScript, Python, Java, etc.

Key Concepts

1. Protocol Buffers (Protobuf)

This is where you define your API structure.

Example:

syntax = "proto3";

package user;

service UserService {
  rpc GetUser (UserRequest) returns (UserResponse);
}

message UserRequest {
  int32 id = 1;
}

message UserResponse {
  int32 id = 1;
  string name = 2;
}

2. Code Generation

From the .proto file, you generate Go code:

protoc --go_out=. --go-grpc_out=. user.proto

Building a gRPC Server in Go

Step 1: Install Dependencies

go mod init grpc-demo
go get google.golang.org/grpc
go get google.golang.org/protobuf

Step 2: Implement the Server

package main

import (
    "context"
    "log"
    "net"

    pb "grpc-demo/user"
    "google.golang.org/grpc"
)

type server struct {
    pb.UnimplementedUserServiceServer
}

func (s *server) GetUser(ctx context.Context, req *pb.UserRequest) (*pb.UserResponse, error) {
    return &pb.UserResponse{
        Id:   req.Id,
        Name: "Kamal",
    }, nil
}

func main() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatal(err)
    }

    grpcServer := grpc.NewServer()
    pb.RegisterUserServiceServer(grpcServer, &server{})

    log.Println("gRPC server running on port 50051...")
    if err := grpcServer.Serve(lis); err != nil {
        log.Fatal(err)
    }
}

Building a gRPC Client in Go

package main

import (
    "context"
    "log"
    "time"

    pb "grpc-demo/user"
    "google.golang.org/grpc"
)

func main() {
    conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure())
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()

    client := pb.NewUserServiceClient(conn)

    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()

    res, err := client.GetUser(ctx, &pb.UserRequest{Id: 1})
    if err != nil {
        log.Fatal(err)
    }

    log.Println("User:", res.Name)
}

gRPC vs REST

Feature	gRPC	REST
Protocol	HTTP/2	HTTP/1.1
Data Format	Binary (Protobuf)	JSON
Performance	Faster	Slower
Streaming	Native support	Limited
Browser Support	Limited	Excellent

When NOT to Use gRPC

Public APIs consumed by browsers
Simple CRUD services
When debugging via browser is important

gRPC shines in internal microservices communication

Pro Tips

Use gRPC Gateway if you need REST + gRPC
Add interceptors for logging/authentication
Combine with Docker for microservices
Use TLS in production

Final Thoughts

gRPC with Go is a powerful combination for building fast, scalable, and modern backend systems. If you're targeting microservices or high-performance systems, it's a must-learn tool.

Understanding Goroutines and Channels in Go

Kamal Rhrabla — Tue, 10 Mar 2026 22:53:57 +0000

Concurrency is one of the biggest reasons developers choose Go. While many languages require complex threading models or external libraries, Go provides a simple and powerful way to handle concurrent tasks using goroutines and channels.

In this article, we’ll explore what goroutines and channels are, how they work, and how you can use them to build efficient concurrent programs.

What is a Goroutine?

A goroutine is a lightweight thread managed by the Go runtime. Unlike operating system threads, goroutines are extremely cheap to create and can scale to thousands or even millions running at the same time.

Creating a goroutine is simple: you just add the go keyword before a function call.

package main

import (
    "fmt"
    "time"
)

func sayHello() {
    fmt.Println("Hello from goroutine")
}

func main() {
    go sayHello()
    time.Sleep(time.Second)
    fmt.Println("Main function finished")
}

What happens here?

The go keyword starts sayHello() in a separate goroutine.

The main function continues executing without waiting.

We add time.Sleep so the program doesn’t exit before the goroutine runs.

In real applications, we typically use synchronization mechanisms instead of sleep.

Why Goroutines Are Powerful

Traditional threads can be heavy and expensive. Goroutines solve this problem by being:

Lightweight, very small memory footprint
Fast to create
Managed by the Go scheduler
Perfect for I/O-heavy tasks

Examples of where goroutines shine:

Web servers handling many requests
Background jobs
API calls to multiple services
Concurrent data processing

The Problem: Sharing Data Between Goroutines

If multiple goroutines run at the same time, how do they communicate safely?

In many languages you would use:

Locks
Mutexes
Shared memory

Go promotes a different philosophy:

“Do not communicate by sharing memory; share memory by communicating.”

This is where channels come in.

What Are Channels?

A channel is a typed conduit that allows goroutines to communicate and synchronize.

You can send values into a channel and receive values from it.

Creating a channel

ch := make(chan int)

This creates a channel that can transmit integers.

Sending and Receiving Data

package main

import "fmt"

func main() {
    ch := make(chan int)

    go func() {
        ch <- 42
    }()

    value := <-ch
    fmt.Println(value)
}

What’s happening?

We create a channel.

A goroutine sends the value 42 into the channel.

The main goroutine receives the value and prints it.

Output:

Channels block by default, meaning:

Sending waits until another goroutine receives
Receiving waits until another goroutine sends
This makes synchronization simple.
Buffered Channels Sometimes you don’t want the sender to block immediately. For that, Go provides buffered channels.

ch := make(chan int, 2)

Example:

package main

import "fmt"

func main() {
    ch := make(chan int, 2)

    ch <- 1
    ch <- 2

    fmt.Println(<-ch)
    fmt.Println(<-ch)
}

Here the channel can store 2 values before blocking.

Using Goroutines with Channels (Real Example)

Let’s run multiple tasks concurrently and collect their results.

package main

import (
    "fmt"
    "time"
)

func worker(id int, ch chan string) {
    time.Sleep(2 * time.Second)
    ch <- fmt.Sprintf("Worker %d finished", id)
}

func main() {
    ch := make(chan string)

    for i := 1; i <= 3; i++ {
        go worker(i, ch)
    }

    for i := 1; i <= 3; i++ {
        fmt.Println(<-ch)
    }
}

Output (order may vary):

Worker 2 finished
Worker 1 finished
Worker 3 finished

Here we:

Start 3 goroutines
Each performs work
Each sends a result back through the channel
The main goroutine collects the results
This pattern is very common in Go.
Closing Channels

Sometimes we want to signal that no more values will be sent.

close(ch)

Example:

for value := range ch {
    fmt.Println(value)
}

The loop automatically stops when the channel is closed.

When to Use Goroutines and Channels

You should consider them when:

Running multiple independent tasks
Making parallel API requests
Processing jobs in background workers
Building high-performance servers
Streaming data between components

Common Beginner Mistakes:

1. Forgetting that goroutines are asynchronous

Your program might exit before goroutines finish.

2. Deadlocks

Example:

fatal error: all goroutines are asleep - deadlock!

This happens when goroutines are waiting on each other with no progress.

3. Overusing goroutines

Just because goroutines are cheap doesn’t mean everything should be concurrent.

Final Thoughts

Goroutines and channels are core features that make Go a powerful language for building scalable and concurrent systems.

Instead of complex thread management, Go gives developers a clean and expressive model for concurrency.

Once you master these two concepts, you'll unlock one of Go’s greatest strengths.

If you're learning Go for backend development, mastering goroutines, channels, and concurrency patterns will significantly improve your ability to build fast and scalable services.

Why Go (Golang) Is Becoming a Favorite Language for Backend Developers

Kamal Rhrabla — Thu, 05 Mar 2026 21:40:11 +0000

In recent years, Go (commonly called Golang) has rapidly gained popularity among backend developers. Originally created at Google in 2009, Go was designed to solve real problems engineers faced when building scalable systems.

Today, Go powers infrastructure and backend systems at companies like Uber, Dropbox, and Netflix.

But what makes Go so attractive for modern backend development?

Let’s explore.

1. Simplicity and Readability

One of the biggest strengths of Go is its minimalist design.

Unlike many modern languages that continuously add complex features, Go intentionally keeps the language simple.

For example:

package main

import "fmt"

func main() {
fmt.Println("Hello, Go!")
}

There are no unnecessary abstractions or complicated syntax rules.

This simplicity allows developers to:

Learn the language quickly
Maintain large codebases more easily
Reduce bugs caused by complex logic

2. Built for Performance

Go is a compiled language, similar to C and C++.

That means Go programs are compiled into native machine code, which makes them significantly faster than interpreted languages.

Compared to languages like:

Python
JavaScript

Go applications often provide much better performance, especially for CPU-intensive backend services.

3. Powerful Concurrency with Goroutines

One of Go’s most famous features is goroutines.

A goroutine is a lightweight thread managed by the Go runtime.

Creating thousands of concurrent tasks is incredibly easy:

go processRequest()

Behind the scenes, Go manages scheduling and execution efficiently.

This makes Go particularly powerful for building:

APIs
Real-time systems
Microservices
Distributed systems

Technologies like Docker and Kubernetes are actually written in Go because of these capabilities.

4. Fast Compilation

Another underrated advantage of Go is extremely fast compilation.

Large Go projects compile in seconds, which significantly improves developer productivity compared to languages with slower build processes.

This fast feedback loop makes Go ideal for modern development environments.

5. Excellent Standard Library

Go ships with a very powerful standard library, which covers many common tasks:

HTTP servers
JSON processing
File handling
Cryptography
Networking

For example, building a simple web server takes just a few lines:

package main

import (
"fmt"
"net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "Hello from Go server!")
}

func main() {
http.HandleFunc("/", handler)
http.ListenAndServe(":8080", nil)
}

With this minimal code, you already have a working web server.

6. Ideal for Microservices

Go has become a top choice for microservice architectures.

Its advantages include:

lightweight binaries
fast startup times
low memory usage
strong concurrency support

These characteristics make Go perfect for cloud-native systems.

This is why many modern cloud tools, including Terraform and Prometheus, are written in Go.

When Should You Use Go?

Go is particularly well suited for:

✔ Backend APIs

✔ Cloud services

✔ DevOps tools

✔ Distributed systems

✔ High-performance network services

However, it may not be ideal for:

complex front-end applications
heavy machine learning workloads

Final Thoughts

Go proves that simplicity can scale.

By focusing on performance, readability, and concurrency, Go has become one of the most powerful languages for building modern backend systems.

Whether you're building APIs, infrastructure tools, or distributed platforms, Go offers a productive and efficient development experience.

If you haven't tried Go yet, it might be the perfect language to add to your backend toolkit.