DEV Community: vaibhavlokhande3000

Why Pull Base Images When You Can Build Your Own?

vaibhavlokhande3000 — Sat, 14 Dec 2024 13:11:39 +0000

Ever wondered why you’re pulling base images like everyone else when you could just… make your own? Revolutionary idea, right?

No more relying on pre-made images, no more "is this secure?" overthinking - it’s time to roll up your sleeves and DIY your container base. And guess what? It’s easier than you think. Let me take you through the process with this simple, step-by-step guide.

(Spoiler: it’ll feel like cooking your own pizza from scratch instead of ordering one online. Bonus satisfaction guaranteed.)

🛠️ What You Need:

Buildah: Your go-to container-building tool.
Ubuntu AMI Server: A clean slate to start with.
Debootstrap: For creating your Ubuntu filesystem.
Container Registry: To store your shiny new creation.

Before diving in, let’s break down Buildah and Debootstrap—the dynamic duo of this process:

🔹 Buildah: A powerful command-line tool for building, modifying, and managing container images, independent of a container runtime. It gives you more flexibility and control.

🔹 Debootstrap: A utility that helps you create a minimal Ubuntu/Debian filesystem, perfect for a lightweight and clean base image.

Together, these tools make building custom container images efficient and streamlined. 🚀

📋 Steps to Create Your Base Image

1. Lets set up our machine first:

For this guide, I’m using an AWS EC2 instance with the Ubuntu AMI.

First, update your machine:

sudo -i
apt update

2. Installing requirements:
Installing Buildah:

apt install buildah

Installing debootstrap:

 apt install debootstrap

3. Launching an empty container:

Now, let’s spin up a completely empty container

buildah from scratch

Container running successfully:
(This is an empty container)

cat /etc/os-release #Check version of your ubuntu os

Mine noble here

4. Mount the container filesystem
We need to access the container like a regular directory. Use the command below to mount the filesystem and store the mount point in scratchmnt:

scratchmnt=$(buildah mount working-container)

5. Creating Ubuntu filesystem in the container directory
Here comes the fun part—use Debootstrap to create a minimal Ubuntu ‘Noble’ filesystem inside the mounted container directory:

debootstrap noble $scratchmnt

Once that's done, you’ll see all the OS files magically appear in the container!

6. Building an image from container:
Now let’s commit your work and package it as a custom image:

 buildah commit working-container vaibhavs_ubuntu_base_image:0.0

Boom! You’ve successfully built your very own Ubuntu image 🎉—give yourself a high-five, you genius!

Check your images:

buildah images    #list images

Time to show off your masterpiece—let’s push that image to the repo and make it official! 🚀

Here are some best options to show off:

Pull My Image and Get Started

You can grab my image from here—go ahead, it’s all yours!

docker pull quay.io/vlokhande3000/ubuntu_image

And there you have it—your very own custom Ubuntu base image!

Benefits of Building Your Own Container Base Image

Greater Control
By building your own base image, you have full control over the environment. You can ensure that only the software and dependencies you need are included, making it more lightweight and secure compared to relying on pre-made images.
Enhanced Security
Custom base images allow you to eliminate unnecessary components and reduce the attack surface. You can ensure the image is up-to-date and free of vulnerabilities by manually installing and configuring only trusted software.
Tailored Environment
You can create a container with exactly the configurations, tools, and libraries you need, optimizing it for your specific use case. This results in a more efficient and purpose-built image compared to a generic one.
No Dependency on External Images
By avoiding pre-built images, you eliminate the need to trust external sources. You can be confident that your image is built exactly the way you want, and there’s no risk of pulling a vulnerable or outdated base image from public repositories.
Improved Performance
Custom base images can be optimized to minimize the size of the container, reducing overhead. This helps improve the performance of your containerized applications, as smaller images take less time to pull and deploy.
Flexibility for Future Modifications
Once you have created your custom base image, you can easily modify it in the future to include additional software, configuration changes, or security updates. It also gives you the flexibility to scale and adapt as your projects evolve.
Satisfaction of Creating from Scratch
Just like cooking your own pizza 🍕, there's something incredibly satisfying about creating a custom container base image from scratch, knowing it’s optimized and built exactly the way you want it.

Thanks!!

Terraform - Creating EC2 instances

vaibhavlokhande3000 — Wed, 06 Nov 2024 11:20:55 +0000

Automating EC2 Instance Creation with Terraform

Hey, devs! Don’t worry you're at the right place! 😉

If you’ve ever had to create multiple EC2 instances through the AWS dashboard, you know it can be a time-consuming process. But there’s a smarter way: Infrastructure as Code (IaC) using Terraform! With Terraform, we can automate the creation and management of AWS resources, including EC2 instances, making our infrastructure repeatable and manageable with just a few commands. Let me walk you through the setup!

🛠 Prerequisites

Before diving into Terraform, make sure you have:

1.AWS CLI Configured: The AWS CLI should be set up and configured on your machine with the necessary permissions.

aws configure #configuring aws account

Enter your access keys and secret access keys when prompted, and you’re good to go!

2.Terraform Installed: Ensure Terraform is installed.
Terraform Documentation
Once these are ready, you’re all set for automation!

Setting Up Your Terraform Project:

First, create a new directory for your Terraform project, which will house all the necessary configuration files.


mkdir ec2_gen #making a directory
cd ec2_gen

Inside this directory, we’ll create a Terraform configuration file that defines our EC2 instances.

📝 Writing the Terraform Configuration

Use a text editor to create the main.tf file. Here, we’ll define our AWS provider, configure the region, and specify the resource (EC2 instances) we want to create.

vim main.tf

Now, add the following configuration to main.tf:

# Specifies Terraform block with required providers and versions
terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"      # Specifies the source for the AWS provider
      version = "~> 4.16"            # Version constraint for the AWS provider
    }
  }
  required_version = ">= 1.9.8"      # Minimum Terraform version required
}

# Configures the AWS provider with a specific region
provider "aws" {
  region = "ap-south-1"              # AWS region (e.g., ap-south-1 for Asia Pacific, Mumbai)
}

# Defines an EC2 instance resource
resource "aws_instance" "my_ec2_instance" {
  ami           = "ami-04a37924ffe27da53"  # Amazon Linux 2 AMI ID (adjust to your region)
  instance_type = "t2.micro"               # Instance type (e.g., t2.micro)
  count         = 2                        # Number of instances to create (2 in this case)

  # Tags help to identify and manage resources
  tags = {
    Name = "terraform-instance-${count.index + 1}"  # Tag instances with unique names
  }
}

# Outputs the public IPs of the created EC2 instances
output "ec2_public_ips" {
  value = aws_instance.my_ec2_instance[*].public_ip  # Outputs the public IP addresses as a list
}

🔍 Explanation of the Code

Provider Block: This block specifies the AWS provider details, including the region. Make sure to adjust the region if you’re working outside of ap-south-1.
Resource Block: Here, we define the aws_instance resource. The count parameter lets us create multiple instances—in this case, 2 EC2 instances.
Tags: We use tags to help identify instances. The name will appear as "example-instance-1," "example-instance-2," and so on.
Output Block: This block outputs the public IPs of our newly created EC2 instances, which can be useful for further automation or SSH access.

Running the Terraform Code

With the configuration complete, let’s initialize and apply it. Here’s the sequence of commands you need to run:

Initialize Terraform: Sets up the working directory and downloads the necessary provider plugins.

terraform init

Validate the Configuration: Checks for syntax errors or misconfigurations.

terraform validate

Plan the Deployment: Shows what Terraform will do without making any actual changes. This is a great way to confirm before deploying.

terraform plan

Apply the Changes: Creates the resources defined in main.tf.

terraform apply

During the apply step, Terraform will prompt you to confirm. Type yes to proceed.

🎉 Verify the Results
Head over to the AWS dashboard and check your EC2 instances. You should see the instances created with the specified tags and configurations. 🚀

wait wait wait...
Created hundreds instances just for fun and don't know how to terminate them?
Don't just do it manually, haha!!

Don’t worry! Just use:

terraform destroy

This command will remove all resources defined in your configuration. Thank me later! 😉

Bonus tip
You can choose Amazon Machine Image by changing AMI ID in the code.

Follow on Linkedin