Forem: Brian Mengo

Creating AWS S3 Bucket using Terraform

Brian Mengo — Sun, 26 Apr 2026 11:36:04 +0000

Introduction
The first resource I create and provision using terraform is the AWS S3 bucket. By writing terraform configuration files (.tf files) to initialise providers and use terraform commands to interact with AWS APIs and provision resources.

AWS CLI for credentials setup before creating any resource in AWS using aws configure.
The below image shows the procedure of provisioning a simple S3 Bucket.

Terraform Configuration
The set up for this resource involves only two block: the provider configuration block and the S3 bucket resource block

The Provider Block
Since we are using the AWS provider we setup by specifying the region in which the resource will be created

provider "aws" {
  region = "us-east-1"
}

S3 Bucket Resource Block

resource "aws_s3_bucket" "demo_bucket" {
  bucket = "devbrio53-store"

  tags = {
    Name        = "My bucket"
    Environment = "Dev"
  }
}

The Terraform resource block starts with the keyword resource, followed by the resource type aws_s3_bucket and a user-defined resource name (e.g., first_bucket).

The bucket name must be globally unique across AWS regions.

Tags are added as a nested block with key-value pairs, e.g., Name and Environment
Tags are strings enclosed in double quotes and enclosed within curly braces, representing a map/dictionary data type in Terraform.

Using Terraform AWS provider documentation to find the correct resource block for an S3 bucket (aws_s3_bucket).
The documentation provides example usage, argument references (mandatory and optional parameters), and guides how to customise the resource block.

Running Terraform Commands to Provision the Bucket

Terraform initialisation is run using the command:

terraform init

This downloads the necessary provider plugins and initialises the backend.

Next, a plan is created using:

terraform plan

This performs a dry run to preview the changes Terraform will apply without actually creating or modifying resources.

The command to apply the changes and create the bucket is:

terraform apply

Terraform prompts for confirmation before applying changes; typing yes proceeds with the creation.

Running terraform plan again shows

Zero resources to add
One resource to change
Zero resources to destroy

Terraform performs a state comparison between the current AWS environment and the configuration file to detect changes.

To delete the created bucket and clean up resources, the command is:

terraform destroy

This removes everything created by the Terraform configuration. It’s a handy way to keep your AWS account clean while learning.

Today’s learning wasn’t just about creating an S3 bucket.

It was about understanding how Terraform connects with AWS, and why authentication is the foundation of everything in cloud.

A simple bucket but a meaningful step forward.

Terraform AWS Provider

Brian Mengo — Thu, 23 Apr 2026 07:27:21 +0000

How Terraform Talks to the Cloud
We begin with an introductory concept of Terraform providers, which is basically a plugin bridging Terraform and cloud providers.
Providers translate Terraform's HCL (HashiCorp Configuration Language) code into API calls understood by cloud platforms like AWS, Azure, or GCP.
When provisioning a resource (e.g., an AWS S3 bucket), Terraform interacts with the cloud provider’s API via the corresponding provider plugin.

Role and Function of Terraform Providers

The provider plugin is responsible for translating Terraform’s configuration into API requests for the target service.
Terraform providers thus enable infrastructure as code by connecting declarative Terraform files with underlying API operations.

Types of Terraform Providers

There are three main categories of Terraform providers:

Official providers: Maintained by the cloud providers themselves (e.g., AWS, Azure, GCP).
Partner providers: Maintained by third-party organisations, not the cloud providers directly.
Community providers: Maintained by the open-source community. Providers can target cloud APIs or other services such as Docker, Kubernetes, Prometheus, and Grafana.

Exploring Terraform AWS Provider Documentation

Users are encouraged to visit the official Terraform AWS provider page on the Terraform Registry (registry.terraform.io).
This page lists all AWS services supported by the provider, enabling provisioning across a broad range of AWS infrastructure components.

Importance of Version Locking and Compatibility

Using the latest Terraform or provider versions by default can cause compatibility issues if your Terraform code is not tested against those versions.
Version locking ensures stability by using the tested combination of Terraform core and provider versions.
Upgrading versions should be done cautiously: test in non-production environments before applying to production.

Understanding Version Constraints and Operators
Terraform supports several operators for version constraints:
Operator Meaning;

= Exact version match only
!= Excludes the specified version
<, <= Allows versions less than (or equal to) the specified version
>, >= Allows versions greater than (or equal to) the specified version
~> (Tilde Greater Than) Allows patch-level updates within the specified minor version (e.g., ~> 6.7.0 allows any version >= 6.7.0 but < 6.8.0)

The tilde operator ~> is commonly used to allow patch upgrades without crossing minor or major version boundaries, preserving compatibility.
Examples:
~> 6.7.0 allows versions 6.7.1, 6.7.2, etc., but not 6.8.0.
~> 1.0 allows versions 1.1, 1.2, etc., but not 2.0.

Creating a Basic Terraform Provider Configuration

# Configure the AWS Provider
provider "aws" {
  region = "us-east-1"
}

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 6.0"
    }
  }
}

# Create a VPC
resource "aws_vpc" "example" {
  cidr_block = "10.0.0.0/16"
}

This Terraform code tells Terraform to use the AWS provider and makes sure it uses a stable version of it. It then sets the AWS region to us-east-1, which means all resources will be created in that location. Finally, the code creates a VPC, which is like a private network inside AWS where you can later add servers, subnets, and other resources.

Terraform Init

Running terraform init or tf init downloads the necessary provider plugins and initialises Terraform in the working directory.
The provider plugin is downloaded automatically based on the system OS (Mac, Windows, Linux).
This step prepares Terraform to interact with the configured provider APIs.

Running terraform plan and Understanding its Output

terraform plan compares the current Terraform configuration with the real infrastructure state.
The plan shows which resources will be created, changed, or destroyed.

Authentication with AWS CLI
Terraform requires valid AWS credentials to interact with AWS services.
The simplest authentication method is running aws configure (AWS CLI tool) to input:

AWS Access Key ID
AWS Secret Access Key
Default region These credentials can be generated from the AWS Management Console under IAM users, with appropriate permissions (e.g., S3 full access). Credentials stored by AWS CLI are then used by Terraform automatically.

Best Practices I Learned
✔ Always specify provider versions
Never rely on defaults.

✔ Use version ranges (not just exact versions)
Keeps things safe but flexible.

✔ Test upgrades in a lower environment
Never update versions directly in production.

✔ Use terraform providers lock
It creates a .terraform.lock.hcl file to ensure consistent builds.

This makes your infrastructure “version-proof”.

Introduction to IAC, how Terraform Works- Day01

Brian Mengo — Tue, 21 Apr 2026 14:59:00 +0000

Day01 of my 30day AWS terraform challenge, and I begin with highlighting what IaC is and how teams are using it to manage infrastructure in the cloud.
Infrastructure as Code (IaC) is the practice of managing and provisioning computing infrastructure through machine-readable configuration files rather than through manual processes or interactive configuration tools.
Think of it like this: instead of clicking through a cloud console to spin up servers, databases, and networks, you write code that describes exactly what you want — and a tool builds it for you.

Tools for Infrastrucure as Code:

Terraform (Multi-cloud and widely used)
Pulumi
AWS CloudFormation, AWS CDK, AWS SAM
Azure ARM / Bicep
GCP Deployment Manager, GCP Config Controller

What is Terraform
Terraform is an open-source IaC tool created by HashiCorp. It allows you to define, preview, and deploy infrastructure across multiple cloud providers — AWS, Azure, Google Cloud, and hundreds more — using a simple, human-readable language called HCL (HashiCorp Configuration Language).

Manual provisioning of Infrastructure Challenges;

Time-consuming: A simple three-tier app infrastructure can take around 2 hours to set up manually.
Complexity grows exponentially when managing multiple environments
Human error risks: Manual steps increase chances of misconfiguration, security oversights, or inconsistent environments
Inconsistency: Different people provisioning environments can lead to "it works on my machine" issues.
High operational costs and delays affecting dependent teams

*Benefits of Terraform
*

Automates the process.
Reduces time needed to perform the same action again and again.
Reduces labour resource which was needed to manual perform the process.
Reduces the chances of human error.
We can track changes using git.

How Terraform Works
Terraform Initialise - Run terraform init to initialize the working directory and download necessary providers.
Validate Configuraion - Run terraform validate to check for syntax or configuration errors.
Terraform Plan - Run terraform plan to preview infrastructure changes before applying.
Terraform apply - Run terraform apply to provision or modify the infrastructure by calling cloud API.
Terraform Destroy - Run terraform destroy to delete resources when no longer needed.

Getting Started

Install Terraform → developer.hashicorp.com/terraform/install
Set up a cloud provider account (AWS Free Tier is great for learning)
Write your first .tf file and run terraform init, terraform plan, terraform apply
Explore the Terraform Registry → registry.terraform.io for modules and providers