DEV Community: Nirmal Chandrasiri

Helm vs Kustomize: A Comprehensive Guide with Examples

Nirmal Chandrasiri — Sat, 08 Feb 2025 14:41:29 +0000

Helm vs Kustomize: A Comprehensive Guide with Real-World Examples

Introduction

When it comes to Kubernetes application management, two popular tools stand out: Helm and Kustomize. Both tools aim to simplify Kubernetes deployments, but they take different approaches. Helm is often compared to a package manager for Kubernetes, while Kustomize offers a declarative way to manage Kubernetes configurations without templating. These tools empower organizations and individuals to deploy applications efficiently and ensure seamless management.

In this guide, we will explore the differences between Helm and Kustomize, their real-world use cases, and how to work with them using example configurations.

What is Helm?

Helm is a package manager for Kubernetes that allows developers to define, install, and upgrade applications using Helm Charts. A Helm Chart is a collection of YAML configuration files that define Kubernetes resources, making it easy to deploy and manage complex applications.

What Does Helm Offer?

Templating system: Enables dynamic configuration using placeholders in YAML files.
Dependency management: Allows defining dependencies between applications.
Version control: Provides versioned application deployments.
Release management: Simplifies rollback, upgrades, and rollouts.

What is Kustomize?

Kustomize is a configuration management tool that lets you customize raw Kubernetes YAML manifests without modifying the original files. Unlike Helm, Kustomize does not use templates; instead, it layers modifications on top of existing configurations.

What Does Kustomize Offer?

Overlay-based configuration management: Apply patches and modifications without altering base YAML files.
No templating: Uses a purely declarative approach without placeholders or variables.
Native support in kubectl: Since Kubernetes 1.14, Kustomize is integrated into kubectl.
Base and overlays structure: Allows for environment-specific configurations.

Helm vs. Kustomize: Key Differences

Feature	Helm	Kustomize
Approach	Templating with Go templates	Patch-based customization
Package Manager	Yes	No
Dependency Mgmt	Supports dependencies	No dependency management
Versioning	Supports versioned releases	No built-in versioning
Learning Curve	Moderate	Easy
Integration	Helm CLI	kubectl built-in

Example: Creating a Helm Chart

Let's create a simple Helm chart for a Nginx deployment.

Step 1: Install Helm

curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

Step 2: Create a New Helm Chart

helm create my-nginx
cd my-nginx

Step 3: Modify the `values.yaml`

replicaCount: 2
image:
  repository: nginx
  tag: latest
service:
  type: ClusterIP
  port: 80

Step 4: Install the Helm Chart

helm install my-release ./my-nginx

Example: Using Kustomize for Nginx

Step 1: Create a Base Deployment

# base/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:latest

Step 2: Create an Overlay for Staging

# overlays/staging/kustomization.yaml
resources:
  - ../../base
patches:
  - target:
      kind: Deployment
      name: nginx
    patch: |-
      - op: replace
        path: "/spec/replicas"
        value: 5

Step 3: Apply the Kustomization

kubectl apply -k overlays/staging/

Helm vs. Kustomize with Real-World Examples

Scenario	Recommended Tool
Deploying packaged applications	Helm
Customizing existing YAML files	Kustomize
Managing application versions	Helm
Applying patches for different environments	Kustomize

Advanced Features of Helm and Kustomize

Helm

Chart repositories: Store and share charts with helm repo.
Hooks: Execute scripts at different points of deployment.
Rollbacks: Easily revert to previous releases.

Kustomize

Transformers: Modify labels, annotations, and images.
Generators: Create ConfigMaps and Secrets dynamically.
Strategic merge patches: Update YAML selectively.

Performance Comparison

Helm: Uses client-side templating and may have performance overhead due to rendering.
Kustomize: Directly applies YAML transformations and is generally faster for modifying existing configurations.

Challenges of Helm and Kustomize

Challenge	Helm	Kustomize
Complexity	Can be complex with templating	Requires structured overlays
Learning Curve	Moderate	Easier
YAML Duplication	Minimal	Can have duplication in overlays

Benefits of Helm and Kustomize

Benefit	Helm	Kustomize
Reusability	High	Moderate
Customization	Templating-based	Overlay-based
Adoption	Widely used in Kubernetes community	Built into `kubectl`

Conclusion

Helm and Kustomize both serve valuable roles in Kubernetes configuration management. Helm is best suited for deploying packaged applications with version control and dependencies, while Kustomize excels in modifying existing YAML manifests for different environments. Choosing the right tool depends on your use case, team workflow, and application complexity.

Would you use Helm, Kustomize, or combination of both? Let me know in the comments!

Until next blog post

Happy Helming and Kustming! 🎉

[Boost]

Nirmal Chandrasiri — Tue, 04 Feb 2025 10:29:47 +0000

Deploying an EC2 Instance Using Terraform

Nirmal Chandrasiri ・ Feb 4

#aws #ec2 #terraform #devops

Deploying an EC2 Instance Using Terraform

Nirmal Chandrasiri — Tue, 04 Feb 2025 10:17:58 +0000

Introduction to Terraform

Terraform is an open-source Infrastructure as Code (IaC) tool developed by HashiCorp. It enables users to define, provision, and manage infrastructure using a declarative configuration language. With Terraform, infrastructure can be treated as code, making deployments more consistent, scalable, and automated.

Why Use IaC Instead of AWS Management Console?

Using the AWS Management Console for creating EC2 instances is straightforward but not scalable. It involves manual effort, which can lead to errors and inconsistencies. With IaC tools like Terraform, you can:

Automate infrastructure provisioning
Maintain consistent deployments
Easily manage infrastructure versions
Reuse code for different environments
Reduce human errors

Prerequisites

Before we proceed ensure that you have:

AWS Account - Sign up for an AWS Account
Terraform Installed - Installation Guide
AWS CLI Installed - Installation Guide
AWS Configuration - Configure AWS credentials using the following command:

   aws configure

You will be prompted to enter:

AWS Access Key ID
AWS Secret Access Key
Default region name
Default output format

Terraform Best Practices

Use Version Control: Store Terraform configurations in Git for tracking changes.
Use Remote State: Store Terraform state files in a remote backend (like S3) to enable collaboration.
Use Variables: Avoid hardcoding values; use variables.tf for flexibility.
Modularize Code: Break down large configurations into reusable modules.
Follow Least Privilege Principle: Provide only necessary permissions to resources.

Terraform Configuration Files

In this section, I'm following best practices by structuring the Terraform configuration into separate files. While it is possible to integrate all the code into a single file, breaking it into multiple files makes it easier to read, update, and manage changes effectively. This modular approach enhances maintainability and reusability.

`main.tf` - Defines the EC2 Instance Resource

This file defines the EC2 instance resource:

resource "aws_instance" "ec2" {
  ami           = var.ami_id
  instance_type = var.instance_type

  tags = {
    Name      = var.instance_name
    timestamp = timestamp()
  }
}

Explanation:

aws_instance "ec2" - Declares an EC2 instance.
ami - Specifies the Amazon Machine Image ID.
instance_type - Defines the type of EC2 instance.
tags - Adds metadata to identify the instance.

`provider.tf` - Configures the AWS Provider

This file specifies the Terraform AWS provider:

terraform {
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "~> 4.16"
    }
  }
  required_version = ">= 1.2.0"
}

provider "aws" {
  region = var.region
}

Explanation:

Defines AWS as the required provider.
Specifies the provider source and version.
Defines the AWS region from the variables.tf file.

`variables.tf` - Defines Input Variables

This file defines input variables:

variable "region" {
  description = "AWS region where resources will be created"
  type        = string
  default     = "us-east-2"
}

variable "ami_id" {
  description = "AMI ID for the EC2 instance"
  type        = string
  default     = "ami-0c7c4e3c6b4941f0f"
}

variable "instance_type" {
  description = "EC2 instance type"
  type        = string
  default     = "t2.micro"
}

variable "instance_name" {
  description = "Name tag for the EC2 instance"
  type        = string
  default     = "Instance-01"
}

Explanation:

Defines region, ami_id, instance_type, and instance_name as variables.
Provides default values for each variable.

`outputs.tf` - Captures Outputs After Execution

This file captures outputs after Terraform execution:

output "instance_id" {
  description = "ID of the created EC2 instance"
  value       = aws_instance.ec2.id
}

output "public_ip" {
  description = "Public IP of the EC2 instance"
  value       = aws_instance.ec2.public_ip
}

Explanation:

Outputs the instance_id and public_ip after resource creation.

Running Terraform

After creating the necessary files, follow these steps to deploy the EC2 instance:

1. Initialize Terraform

terraform init

Explanation:

Downloads necessary provider plugins.
Prepares the working directory for Terraform commands.

2. Validate Configuration

terraform validate

Explanation:

Checks if the configuration syntax is correct.
Ensures all required fields are specified.

3. Plan Execution

terraform plan

Explanation:

Shows what Terraform will create without applying changes.
Helps verify expected modifications before execution.

4. Apply Configuration

terraform apply

Explanation:

Deploys resources as per the configuration.
Prompts for confirmation before executing.
Once confirmed, creates the EC2 instance.

4. Remove Resources

terraform destroy

⚠️ Please make sure to destroy resource if you don't want it anymore otherwise you will be charged.

Conclusion

We can use Terraform to deploy an EC2 instance automates the process, ensuring consistency and scalability. By following best practices, using variables, and leveraging IaC principles, managing cloud infrastructure becomes more efficient and reliable.

Shell Script to Monitor Linux Server Resources

Nirmal Chandrasiri — Sat, 18 Jan 2025 06:33:26 +0000

Introduction

Phew! After a long time, I’ve finally planned to write a simple blog post on Dev. So, let’s dive in!

We all know that effective server monitoring is essential for maintaining system stability and performance. In this blog post, I’ll show you how to create an enhanced shell script that monitors CPU usage, memory usage, disk space, network activity, running processes, and system uptime in real time.

Prerequisites

Before we begin, ensure you have:

Ubuntu Instance: Any Ubuntu-based system or virtual machine.
Basic Knowledge of Shell Scripting: Familiarity with terminal commands and scripting basics.

Step 1: Create a File in Ubuntu

Start by creating a file for your script. Open a terminal and use your preferred text editor. Here, we’ll use vim:

vim monitor_linux.sh

Step 2: Write the Shell Script

Add the following script to the file:

#!/bin/bash

while true; do
 clear
 echo "System Resource Monitoring"
 echo "--------------------------"

 # Display CPU usage
 echo "CPU Usage:"
 top -n 1 -b | grep "Cpu"

 # Display memory usage
 echo -e "\nMemory Usage:"
 free -h

 # Display disk space usage
 echo -e "\nDisk Space Usage:"
 df -h

 # Display top 5 processes by memory usage
 echo -e "\nTop 5 Processes by Memory Usage:"
 ps -eo pid,ppid,cmd,%mem --sort=-%mem | head -6

 # Display network usage
 echo -e "\nNetwork Usage (bytes received and transmitted):"
 echo "Interface  RX Bytes  TX Bytes"
 cat /proc/net/dev | tail -n +3 | awk '{print $1, $2, $10}'

 # Display system uptime
 echo -e "\nSystem Uptime:"
 uptime -p

 sleep 5 # Wait for 5 seconds before the next update
done

Step 3: Make the Script Executable

Give the script execute permissions:

chmod +x monitor_linux.sh

Step 4: Run the Script

Run the script to monitor your server:

./monitor_linux.sh

The script will display updated system information every 5 seconds. To stop the script, please use CTRL + C.

Here is the in detail of this script:

CPU Usage: The top command displays current CPU utilization.
Memory Usage: The free command shows memory statistics in a human-readable format.
Disk Space Usage: The df command shows disk space usage for all mounted filesystems.
Top 5 Processes: The ps command lists the top 5 memory-consuming processes.
Network Usage: Displays bytes received and transmitted for each network interface using /proc/net/dev.
System Uptime: The uptime command shows how long the system has been running.

Conclusion

This simple shell script offers a comprehensive view of your Linux server’s performance metrics. You can easily customize it further to include additional monitoring features like I/O statistics, swap usage, or alert mechanisms.

I’m planning to share more technical posts in the future, covering topics like AWS, Kubernetes, Prometheus, Elastic, and more. Until next time, happy learning!

Front-End Web and Mobile Development on AWS

Nirmal Chandrasiri — Sun, 16 Jan 2022 06:16:13 +0000

AWS offers a wide range of tools and services to support development workflows for iOS, Android, React Native, and web front-end developers. There is a set of services that make it easy to build, test, and deploy an application, even with minimal knowledge of AWS. With the speed and reliability of the AWS infrastructure, mobile and web applications can scale from prototype to millions of users to provide a better user experience and better solutions for the whole integrated system.

Amazon services are primarily aimed at developing web and mobile
applications:

Ease of use and minimal energy to start. Amazon services allow you to develop an application using existing iOS/Android IDEs and web frameworks. This makes it easy to add UI components for a user-friendly interface and use the CLI tool chain to easily customize the back end.
Provide access to the features you need. You can use Auth, Analytics, API, Storage, Predictions, XR, and others to create rich server infrastructures. GraphQL can be used to access and integrate data in flexible ways. Amazon services offer the ability to test mobile applications on hundreds of real devices.

A scalable approach allows you to grow your business quickly with built-in AWS best practices for security, availability, and reliability; your application can easily scale from one request per second with microsecond latency around the world.

Let's look at which of the Amazon services will help in the development and operation of web and mobile solutions, as well as speed up the whole process and make it more stable.

AWS Amplify

AWS Amplify is a collection of tools and services that enable developers of mobile applications and web interfaces to build secure and scalable end-to-end systems on AWS. With Amplify, you can easily create custom workflows, develop voice interfaces, connect artificial intelligence to real-time data streams, run targeted advertising campaigns, and so on. AWS Amplify will help you develop and deliver quality applications.

AWS Amplify includes an open-source platform with separate libraries for specific use cases and a wide range of tools for building cloud functionality and incorporating them into applications, as well as a web hosting service for deploying static web applications.

Within minutes of configuring the appropriate service, a developer can automatically configure a best-in-class backend service for mobile and web applications, such as an authentication service, data warehouse, or API based on Amazon S3, Amazon Cognito, and other AWS services.

Amplify CLI seamlessly integrates with iOS and Android IDEs, as well as many popular web development frameworks, providing a guided workflow to customize the optimal backend for your applications with a few simple commands.

AWS Amplify Console

The AWS Amplify Console is a static web hosting service that accelerates the application release cycle with an uncomplicated CI/CD process for building and deploying static web applications. You only need to provide a link to the repository with your application code in the console, and all adjustments in the frontend and backend will be deployed in a single workflow every time you commit the code.

A complex application includes a frontend hosted on a single-page application framework (such as React, Angular, Vue, Gatsby, or Flutter, which is now in developer preview) and an optional cloud-based backend (such as GraphQL, REST API, file and data stores).

These main features allow you to integrate web and mobile applications with Amazon:

Authentication (User Registration and Authentication)
Data storage (offline sync and conflict resolution)
API (GraphQL and REST - Accessing Data from Multiple Data Sources)
Storage (User Content Management)
Analytics (Collecting analytic data for your application)
Forecasting (Artificial Intelligence/Machine Learning, including text broadcasts)
Interactions (Conversational Chatbots)
Push notifications (Sending targeted messages)
PubSub (Post and Subscription Management)

AWS AppSync

AWS AppSync simplifies application development by letting you create a universal API to securely access, modify, and combine data from multiple sources. AppSync is a managed service that uses GraphQL so that applications can easily retrieve only the data they need.

With AppSync, you can build scalable applications, including those requiring real-time updates, using a range of data sources such as NoSQL data stores, relational databases, HTTP APIs, and native data sources with AWS Lambda.

For mobile and web applications, AppSync also provides access to local data when devices go offline and sync data when they reconnect to the Internet. In this case, the client can customize the order of conflict resolution. AWS AppSync is available in different regions.

You can develop your application in a familiar IDE (for example, Xcode, Android Studio, VS Code), and use the intuitive AWS AppSync or AWS Amplify CLI management console to automatically generate APIs and client code.

AWS AppSync integrates with Amazon DynamoDB, Amazon Aurora, Amazon Elasticsearch, AWS Lambda, and other AWS services, allowing you to build complex applications with nearly unlimited performance and storage that can change based on your business needs.

AWS AppSync provides real-time subscriptions to millions of devices and offline access to application data. Once the device is reconnected, AWS AppSync syncs only the updates at the time the device was disconnected, not the entire database. AWS AppSync offers configurable server-side conflict detection and resolution.

It is also possible to perform complex queries and generalizations across multiple data sources with a single network call using GraphQL. AWS AppSync makes it easy to protect your application data by using multiple authentication modes at the same time and also allows you to determine the severity of the threat and perform granular access control at the data definition level directly from your GraphQL schema.

Amazon API Gateway

Amazon API Gateway is a fully managed developer service for building, publishing, maintaining, monitoring, and securing APIs at scale. Applications access the data, business logic, or functionality of your backend services through the API. API Gateway allows you to create RESTful and WebSocket APIs, which are the main component of real-time two-way communication applications. API Gateway supports containerized and serverless workloads and Internet applications.

API Gateway takes care of all the tasks associated with accepting and processing hundreds of thousands of concurrent API calls, including traffic management, CORS support, authorization, and access control, request throttling, and API monitoring and versioning. Working with API Gateway does not require minimum fees or start-up investments. This only pays for the received API calls and the amount of data transferred, and you can use API Gateway's tiered pricing model to reduce application costs as you scale your API usage.

REST API and WebSocket are very important features for web and mobile application development:

REST API. Allows you to create RESTful APIs optimized for serverless workloads and HTTP servers using HTTP APIs. HTTP APIs are the best way to create APIs that only require an API proxy. If your API requires API proxy functionality and API management capabilities in a single solution, API Gateway also provides REST APIs.
WebSocket API. Allows you to create real-time two-way communication applications such as chat apps and streaming panels using the WebSocket API. API Gateway maintains a persistent communication to handle messages passed between your backend service and your clients.

API Gateway provides a tiered pricing model for API requests. At just $0.90 per one million API requests at the highest level, a developer can reduce their costs by increasing the number of API requests per region across all of your AWS accounts.

By the way, it is possible to monitor performance metrics and information about API calls, data latency, and error rates in the API Gateway control panel. This will allow you to visually control calls to your services using Amazon.

It is easy to set up API access using AWS Identity and Access Management (IAM) and Amazon Cognito. By using OAuth tokens, you leverage the built-in support for OIDC and OAuth2 API Gateway. To support custom authorization requirements, you can run the Lambda Authorization Tool from AWS Lambda.

AWS Device Farm

AWS Device Farm is an application testing service that improves the performance of mobile and web applications. It uses a variety of desktop browsers and real mobile devices, so the developer doesn't need to create his own test framework. The service allows you to run tests simultaneously in multiple browsers for desktop computers or use real mobile devices. This speeds up the testing process, which also generates videos and logs to quickly identify bugs in your application.

Automated testing. Test applications in parallel on multiple physical devices in the AWS Cloud. With the built-in Amazon infrastructures, the user is able to test their applications without any scripting.
Testing on devices that potential users work with. It is possible to run tests on a wide variety of physical devices. Unlike emulators, physical devices allow you to more accurately determine how users interact with your application while taking into account factors such as memory size, processor usage, location, and firmware or software changes made by the manufacturer or operator. The base of devices in Amazon is constantly growing.
Playback and quick troubleshooting. The service allows you to manually reproduce problems and run automatic testing in parallel. The service collects videos, logs, and performance data, which will provide detailed information about the problem and help you quickly solve it. In automated testing, problems are identified and grouped.

In doing so, you can set the location, language settings, network connection settings, application data, and install the required applications.

It is possible to use open source testing frameworks such as Appium, Calabash, or Espresso. Testing can also be performed manually using remote access. For automated tests and to retrieve results from IDEs, it is possible to use continuous integration environments such as Android Studio or Jenkins.

For web applications, testing is available in multiple desktop browsers and in different browser versions. This allows tests to run across multiple desktop browsers, including Chrome, Firefox, and Internet Explorer, to ensure that applications work properly across multiple browsers.

Amazon Pinpoint

Amazon Pinpoint is a flexible and scalable service for inbound and outbound marketing communications. It allows you to interact with your customers through channels such as email, SMS, push notifications, or voice. Amazon Pinpoint is easy to set up, easy to use, and flexible to fit any marketing interaction scenario.

This allows you to segment your campaign audience by customer type and customize your messages by filling them with relevant content. Amazon Pinpoint delivery and campaign metrics measure the success of your engagement. Amazon Pinpoint can grow with your business and scale to billions of messages per day across all communication channels.

Conclusion

We discovered in this article Front-End Web and
Mobile Development on AWS Features.

Hope you enjoyed reading this blog post.

If you have any questions or feedback, please feel free to leave a comment.

Thanks for reading!

Documentation

DEV Community: Nirmal Chandrasiri

Helm vs Kustomize: A Comprehensive Guide with Examples

Helm vs Kustomize: A Comprehensive Guide with Real-World Examples

Introduction

What is Helm?

What Does Helm Offer?

What is Kustomize?

What Does Kustomize Offer?

Helm vs. Kustomize: Key Differences

Example: Creating a Helm Chart

Step 1: Install Helm

Step 2: Create a New Helm Chart

Step 3: Modify the values.yaml

Step 4: Install the Helm Chart

Example: Using Kustomize for Nginx

Step 1: Create a Base Deployment

Step 2: Create an Overlay for Staging

Step 3: Apply the Kustomization

Helm vs. Kustomize with Real-World Examples

Advanced Features of Helm and Kustomize

Helm

Kustomize

Performance Comparison

Challenges of Helm and Kustomize

Benefits of Helm and Kustomize

Conclusion

[Boost]

Deploying an EC2 Instance Using Terraform

Nirmal Chandrasiri ・ Feb 4

Deploying an EC2 Instance Using Terraform

Introduction to Terraform

Why Use IaC Instead of AWS Management Console?

Prerequisites

Terraform Best Practices

Terraform Configuration Files

main.tf - Defines the EC2 Instance Resource

provider.tf - Configures the AWS Provider

variables.tf - Defines Input Variables

outputs.tf - Captures Outputs After Execution

Running Terraform

1. Initialize Terraform

2. Validate Configuration

3. Plan Execution

4. Apply Configuration

4. Remove Resources

Conclusion

Shell Script to Monitor Linux Server Resources

Introduction

Prerequisites

Front-End Web and Mobile Development on AWS

Step 3: Modify the `values.yaml`

`main.tf` - Defines the EC2 Instance Resource

`provider.tf` - Configures the AWS Provider

`variables.tf` - Defines Input Variables

`outputs.tf` - Captures Outputs After Execution