DEV Community: Kishore Suzil

How to Set Up Environment Variables in Docker Containers

Kishore Suzil — Wed, 12 Mar 2025 18:35:18 +0000

How to Set Up Environment Variables in Docker Containers

Environment variables are crucial in Docker for configuring containerized applications dynamically. This guide covers multiple methods to set environment variables inside Docker containers.

Step 1: Install Docker

Ensure Docker is installed:

docker --version

If Docker is not installed:

Linux (Ubuntu):

  sudo apt update
  sudo apt install docker.io -y

Mac/Windows: Install Docker Desktop

Step 2: Create a Sample Web Application

We’ll create a simple Node.js web app that reads environment variables.

(A) Create a Project Directory

mkdir my-web-app && cd my-web-app

(B) Initialize a Node.js Project

npm init -y

(C) Install Dependencies

npm install express dotenv

(D) Create `server.js` File

touch server.js

(E) Add the Following Code in `server.js`

require('dotenv').config();
const express = require('express');
const app = express();

const PORT = process.env.PORT || 3000;
const DB_HOST = process.env.DB_HOST || 'localhost';
const DB_USER = process.env.DB_USER || 'root';
const DB_PASS = process.env.DB_PASS || 'password';

app.get('/', (req, res) => {
  res.send(`Connected to DB: ${DB_HOST} with user ${DB_USER}`);
});

app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

✅ This app will display database credentials stored in environment variables.

Step 3: Create a `Dockerfile`

FROM node:18
WORKDIR /app
COPY package.json .
RUN npm install
COPY . .
EXPOSE 3000
CMD ["node", "server.js"]

Step 4: Build and Run the Docker Container (Using `-e` Flag)

(A) Build the Docker Image

docker build -t my-web-app .

(B) Run the Container with Environment Variables

docker run -d -p 3000:3000 \
  -e DB_HOST=mysql \
  -e DB_USER=admin \
  -e DB_PASS=secret \
  my-web-app

Step 5: Verify the Running Container

docker ps

Step 6: Test the Application

Open your browser and visit:
👉 http://localhost:3000

You should see:

Connected to DB: mysql with user admin

Step 7: Use a `.env` File (Alternative Method)

(A) Create a `.env` File

vim .env

(B) Add This Content to `.env`

DB_HOST=mysql
DB_USER=admin
DB_PASS=secret
PORT=3000

(C) Modify `docker-compose.yml` to Load the `.env` File

version: "3.8"
services:
  web:
    image: my-web-app
    build: .
    ports:
      - "3000:3000"
    env_file:
      - .env

(D) Run the App Using Docker Compose

docker-compose up -d

✅ This method automatically loads environment variables from .env.

Step 8: Stopping & Cleaning Up

To stop the running container:

docker stop <container_id>

To remove all stopped containers:

docker rm $(docker ps -aq)

Final Summary

Method	Command
Using `-e` flag	`docker run -d -e DB_HOST=mysql -e DB_USER=admin -e DB_PASS=secret my-web-app`
Using `.env` file with Docker Compose	`docker-compose up -d`
Checking Environment Variables Inside Container	`docker exec -it <container_id> env`

Scaling Services with Docker Compose

Kishore Suzil — Wed, 12 Mar 2025 18:21:52 +0000

🚀 Scaling Services with Docker Compose

Scaling services with Docker Compose is a great way to simulate load balancing and improve availability. Here’s a step-by-step guide to scaling a web service in a multi-container application.

Step 1: Create a Multi-Container Application

We'll define a web service using Nginx and a load balancer with Nginx.

Directory Structure

docker-compose-scaling/
│── docker-compose.yml
│── web/
│   ├── Dockerfile
│   ├── index.html
│── nginx.conf

Step 2: Define the Web Service

Dockerfile for the Web Service (`web/Dockerfile`)

FROM nginx:latest
COPY index.html /usr/share/nginx/html/index.html

Explanation:

FROM nginx:latest → Uses the official Nginx image as the base image.
COPY index.html /usr/share/nginx/html/index.html → Copies the HTML file into the default Nginx directory.

Sample HTML Page (`web/index.html`)

<!DOCTYPE html>
<html>
<head>
    <title>Scaled Web Service</title>
</head>
<body>
    <h1>Welcome to the Scaled Web Service</h1>
</body>
</html>

Step 3: Define `docker-compose.yml`

version: '3'

services:
  web:
    image: nginx  # Using Nginx as a web server
    deploy:
      replicas: 3  # Scale to 3 instances
    volumes:
      - ./web:/usr/share/nginx/html  # Mount your web app files (index.html)
    networks:
      - webnet

  load_balancer:
    image: nginx
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro  # Custom Nginx config for load balancing
    ports:
      - "8081:80"  # Exposing only the load balancer to avoid port conflicts
    depends_on:
      - web
    networks:
      - webnet

networks:
  webnet:

Explanation:

web service runs three replicas of Nginx.
load_balancer uses Nginx for load balancing.
Services communicate via webnet.

Step 4: Configure Load Balancer

Nginx Configuration (`nginx.conf`)

events {}

http {
    upstream web_backend {
        server web:80;
        server web:80;
        server web:80;
    }

    server {
        listen 80;

        location / {
            proxy_pass http://web_backend;
        }
    }
}

Step 5: Scale the Service Using Docker Compose

Run the following command to start and scale the service:

docker-compose up --scale web=3 -d

Step 6: Test the Scaled Application

Open your browser and visit:

http://localhost:8081

Check running containers:

docker ps

How Load Balancing Works

When multiple instances of a service run, requests are distributed among them.
Nginx acts as a reverse proxy and uses round-robin to distribute traffic.

Monitor Docker Logs in Real-Time with a Simple Bash Script

Kishore Suzil — Wed, 12 Mar 2025 18:06:20 +0000

Step 1: Ensure Docker is Installed and Running

Make sure you have Docker installed and running on your system.

To check if Docker is installed, run:

docker --version

To verify if Docker is running, use:

docker ps

If Docker is not running, start it using:

sudo systemctl start docker

Step 2: Create the Log Monitoring Script

Open a terminal and create a new script file:

vim monitor_docker_logs.sh

Copy and paste the following script into the file:

#!/bin/bash

# Define log file
LOG_FILE="consolidated_logs.log"
ERROR_LOG_FILE="error_logs.log"

# Get list of all running containers
CONTAINERS=$(docker ps --format "{{.Names}}")

# Check if containers are running
if [ -z "$CONTAINERS" ]; then
    echo "No running containers found. Exiting..."
    exit 1
fi

# Clear previous log files
echo "" > $LOG_FILE
echo "" > $ERROR_LOG_FILE

# Collect logs from all running containers
echo "Collecting logs..."
for CONTAINER in $CONTAINERS; do
    echo "--- Logs from $CONTAINER ---" >> $LOG_FILE
    docker logs --tail 100 $CONTAINER >> $LOG_FILE 2>&1
    echo "\n" >> $LOG_FILE
done

echo "Logs consolidated in $LOG_FILE"

# Monitor logs for errors
echo "Scanning for errors..."
grep -i "error" $LOG_FILE > $ERROR_LOG_FILE

if [ -s $ERROR_LOG_FILE ]; then
    echo "Errors found! Check $ERROR_LOG_FILE for details."
else
    echo "No errors found."
fi

# Real-time monitoring (optional)
echo "Monitoring logs in real-time..."
tail -f $LOG_FILE

Step 3: Grant Execute Permissions

Make the script executable by running:

chmod +x monitor_docker_logs.sh

Step 4: Run the Script

Start the script by executing:

./monitor_docker_logs.sh

Step 5: Check the Log Files

Once the script runs, it will generate two log files:

consolidated_logs.log → Contains all logs from running containers.
error_logs.log → Extracts error messages from the logs.

To view the logs, use:

cat consolidated_logs.log

To check for errors, use:

cat error_logs.log

Step 6: Keep Monitoring Logs in Real-Time (Optional)

To continuously monitor logs, use:

tail -f consolidated_logs.log

Step 7: Stop the Script

If you want to stop real-time monitoring, press CTRL + C.

Automate Docker Container Management with a Simple Bash Script

Kishore Suzil — Wed, 12 Mar 2025 17:53:24 +0000

🛠 Prerequisites

Ensure you have Docker installed on your system:

Windows/Mac: Install Docker Desktop
Linux (Ubuntu Example):

  sudo apt update
  sudo apt install docker.io -y
  sudo systemctl enable --now docker

Verify installation:

  docker --version

📌 Understanding Key Docker Commands

Before automating, familiarize yourself with these Docker commands:

List all running containers:

  docker ps

List all containers (including stopped ones):

  docker ps -a

Start a container:

  docker start <container_name_or_id>

Stop a container:

  docker stop <container_name_or_id>

Remove a container:

  docker rm <container_name_or_id>

📝 Writing the Automation Script

Create a new Bash script file:

vim manage_docker.sh

Paste the following script:

#!/bin/bash

echo "Docker Container Management Script"
echo "1. Start a container"
echo "2. Stop a container"
echo "3. Remove a container"
read -p "Choose an option (1-3): " option

case $option in
    1)
        read -p "Enter container name or ID to start: " container
        docker start "$container"
        echo "Container started."
        ;;
    2)
        read -p "Enter container name or ID to stop: " container
        docker stop "$container"
        echo "Container stopped."
        ;;
    3)
        read -p "Enter container name or ID to remove: " container
        docker rm "$container"
        echo "Container removed."
        ;;
    *)
        echo "Invalid option. Exiting."
        ;;
esac

Save and exit: CTRL + X, then Y, and hit Enter.

✅ Running the Script

Give execution permission:

   chmod +x manage_docker.sh

Run the script:

   ./manage_docker.sh

Follow the prompts to start, stop, or remove a container. 🎯

Deploying a Static Website on AWS S3 & EC2 Using Terraform" published: true

Kishore Suzil — Sun, 02 Mar 2025 15:59:19 +0000

Deploying a Static Website on AWS S3 & EC2 Using Terraform

Infrastructure as Code (IaC) simplifies cloud management. In this guide, we'll automate the deployment of a static website on AWS S3 and create an EC2 instance using Terraform.

What We'll Cover

S3 Bucket Creation & Hosting – Automating website deployment.
Bucket Policy for Public Access – Ensuring public accessibility.
EC2 Instance Creation – Managing compute resources.
Using Variables & Outputs – Making the configuration reusable.

Prerequisites

AWS account with CLI configured (aws configure)
Terraform installed (terraform -v)

Step 1: Configure Terraform & AWS Provider

Create a main.tf file and define the Terraform and AWS provider configuration:

terraform {
  required_version = ">= 1.7.4"
  required_providers {
    aws = {
      source  = "hashicorp/aws"
      version = "5.40.0"
    }
  }
}

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

Step 2: Create an S3 Bucket for Static Website Hosting

resource "aws_s3_bucket" "website_bucket" {
  bucket = "my-static-website-43234"
}

resource "aws_s3_bucket_website_configuration" "website_config" {
  bucket = aws_s3_bucket.website_bucket.id
  index_document {
    suffix = "index.html"
  }
}

resource "aws_s3_object" "index_file" {
  bucket        = aws_s3_bucket.website_bucket.id
  key           = "index.html"
  source        = "index.html"
  content_type  = "text/html"
  etag          = filemd5("index.html")
}

Step 3: Configure Public Access Policy

resource "aws_s3_bucket_public_access_block" "public_access" {
  bucket                  = aws_s3_bucket.website_bucket.id
  block_public_acls       = false
  block_public_policy     = false
}

resource "aws_s3_bucket_policy" "allow_public_access" {
  bucket = aws_s3_bucket.website_bucket.id
  policy = jsonencode({
    Version = "2012-10-17"
    Statement = [
      {
        Sid       = "PublicReadGetObject"
        Effect    = "Allow"
        Principal = "*"
        Action    = "s3:GetObject"
        Resource  = "${aws_s3_bucket.website_bucket.arn}/*"
      }
    ]
  })
  depends_on = [aws_s3_bucket_public_access_block.public_access]
}

Step 4: Create an EC2 Instance

resource "aws_instance" "web_server" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t2.micro"

  tags = {
    Name = "WebServerInstance"
  }
}

Step 5: Use Variables & Outputs

Define variables in variables.tf:

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

variable "website_bucket_name" {
  description = "S3 bucket name for website hosting"
  type        = string
  default     = "my-static-website-43234"
}

Define outputs in outputs.tf:

output "website_url" {
  value = "http://${aws_s3_bucket.website_bucket.bucket}.s3-website.${provider.aws.region}.amazonaws.com"
}

output "ec2_instance_id" {
  value = aws_instance.web_server.id
}

output "ec2_public_ip" {
  value = aws_instance.web_server.public_ip
}

Step 6: Deploy with Terraform

terraform init
terraform plan
terraform apply -auto-approve

To destroy the infrastructure:

terraform destroy -auto-approve

Conclusion

By following these steps, you automated the deployment of an S3-hosted static website and an EC2 instance using Terraform. This approach ensures reproducibility, scalability, and efficient cloud management. 🚀

🚀 CPU & Memory Monitoring Script

Kishore Suzil — Sun, 02 Mar 2025 13:29:58 +0000

Overview

This project provides a Bash script to monitor CPU and Memory usage on a Linux server. The script logs high resource usage and helps in proactive system administration.

🛠️ Prerequisites

Ensure your Linux system supports the following commands:

ps for listing processes
df for checking disk usage
free for monitoring memory
uptime for system uptime details

📝 Bash Script: `monitor_usage.sh`

#!/bin/bash

# Define CPU and Memory usage thresholds
CPU_THRESHOLD=80.0  # Stop if any process exceeds 80% CPU usage
MEM_THRESHOLD=70.0  # Stop if any process exceeds 70% memory usage

# Print current time and system uptime
echo "Current time: $(date '+%Y-%m-%d %H:%M:%S')"
echo "System uptime: $(uptime)"

# Display disk usage
echo "Disk usage:"
df -h --output=source,pcent | grep -v "Use%"

# Display available memory
echo "Free memory: $(free -m | awk 'NR==2 {print $4}') MB"

# Display system load average
echo "Load average: $(cat /proc/loadavg | awk '{print $1,$2,$3}')"

echo "-----------------------------------------------"

# Check for high CPU usage
HIGH_CPU_PROCESS=$(ps -eo pid,%cpu,cmd --sort=-%cpu | awk -v threshold="$CPU_THRESHOLD" '$2>threshold {print $1, $2, $3; exit}')
if [[ ! -z "$HIGH_CPU_PROCESS" ]]; then
  echo "❌ High CPU Usage Detected: $HIGH_CPU_PROCESS"
  echo "$(date) - High CPU Usage: $HIGH_CPU_PROCESS" >> high_usage_log.txt
fi

# Check for high memory usage
HIGH_MEM_PROCESS=$(ps -eo pid,%mem,cmd --sort=-%mem | awk -v threshold="$MEM_THRESHOLD" '$2>threshold {print $1, $2, $3; exit}')
if [[ ! -z "$HIGH_MEM_PROCESS" ]]; then
  echo "❌ High Memory Usage Detected: $HIGH_MEM_PROCESS"
  echo "$(date) - High Memory Usage: $HIGH_MEM_PROCESS" >> high_usage_log.txt
fi

echo "-----------------------------------------------"

# Exit the script after completing one run
exit 0

🔄 Running the Script

Make the script executable:

   chmod +x monitor_usage.sh

Run the script:

   ./monitor_usage.sh

📊 Summary

✅ Monitors CPU & Memory usage

✅ Logs high resource-consuming processes

🚀 Ansible Real-Time Project:

Kishore Suzil — Sun, 02 Mar 2025 13:23:28 +0000

Automating AWS EC2 Management

Overview

This project demonstrates how to use Ansible to automate the provisioning and management of AWS EC2 instances. The tasks include:
✅ Creating multiple EC2 instances using loops

✅ Setting up passwordless authentication

✅ Automating the shutdown of Ubuntu instances using conditionals

🛠️ Prerequisites

Before running the playbooks, ensure you have:

Ansible Installed on the control node.
AWS CLI Configured with an IAM user having EC2 permissions.
Boto3 and botocore installed using:

   pip install boto3 botocore

SSH Key Pair for authentication.

📌 Task 1: Create EC2 Instances using Ansible Loops

We will create:

2 Ubuntu instances
1 CentOS instance

Playbook: `create_instances.yml`

- hosts: localhost
  connection: local

  tasks:
  - name: Create EC2 instances
    amazon.aws.ec2_instance:
      name: "{{ item.name }}"
      key_name: "key.pem"
      instance_type: t2.micro
      security_group: default
      region: ap-south-1
      aws_access_key: "{{ec2_access_key}}"  # From vault as defined
      aws_secret_key: "{{ec2_secret_key}}"  # From vault as defined      
      network:
        assign_public_ip: true
      image_id: "{{ item.image }}"
      tags:
        environment: "{{ item.name }}"
    loop:
      - { image: "ami-0e1d06225679bc1c5", name: "manage-node-1" } # Update AMI ID according 
      - { image: "ami-0f58b397bc5c1f2e8", name: "manage-node-2" } # to your account
      - { image: "ami-0f58b397bc5c1f2e8", name: "manage-node-3" }

Run the playbook:

ansible-playbook create_instances.yml

📌 Task 2: Set Up Passwordless Authentication

After launching the instances, we will fetch their public IPs and configure SSH key-based authentication.

Playbook: `setup_passwordless_auth.yml`

- name: Configure passwordless authentication
  hosts: localhost
  connection: local
  gather_facts: no
  tasks:
    - name: Fetch Instance Public IPs
      amazon.aws.ec2_instance_info:
        region: "us-east-1"
      register: ec2_info

    - name: Extract Public IPs
      set_fact:
        ubuntu_ips: "{{ ec2_info.instances | selectattr('image_id', 'equalto', 'ami-0c55b159cbfafe1f0') | map(attribute='public_ip_address') | list }}"
        centos_ip: "{{ ec2_info.instances | selectattr('image_id', 'equalto', 'ami-0c322300a1dd5dc79') | map(attribute='public_ip_address') | first }}"

    - name: Copy SSH Key to Instances
      ansible.builtin.shell: ssh-copy-id -f -o IdentityFile=<Add the path of the key> ubuntu@{{ item }}
      loop: "{{ ubuntu_ips }}"
      ignore_errors: yes

    - name: Copy SSH Key to CentOS Instance
      ansible.builtin.shell: ssh-copy-id -f -o IdentityFile=<Add the path of the key> centos@{{ centos_ip }}
      ignore_errors: yes

Run the playbook:

ansible-playbook setup_passwordless_auth.yml

📌 Task 3: Automate Shutdown of Ubuntu Instances Using Conditionals

We will use Ansible’s when condition to target only Ubuntu instances for shutdown.

Playbook: `shutdown_ubuntu.yml`

- name: Shutdown Ubuntu Instances
  hosts: all
  gather_facts: yes
  tasks:
    - name: Shutdown Ubuntu servers
      ansible.builtin.command: shutdown -h now
      when: ansible_facts['distribution'] == "Ubuntu"

Run the playbook:

ansible-playbook -i inventory shutdown_ubuntu.yml

🎯 Summary

✅ Created 3 EC2 instances using Ansible loops

✅ Set up passwordless authentication

✅ Automated shutdown of Ubuntu instances using conditionals

Deploying a Static Website on AWS S3 Using Terraform

Kishore Suzil — Thu, 27 Jun 2024 18:22:22 +0000

Introduction :

In this step-by-step guide, we’ll dive into deploying a static website on AWS S3 using Terraform! We’ll walk through the process of:

Automating S3 Bucket Creation: Terraform will handle creating the S3 bucket where your website files will reside.
Effortless Website Upload: We’ll configure Terraform to skip manual uploads by referencing your website files locally.
Public Access for All: Terraform will configure the S3 bucket policy to grant public read access, ensuring anyone can access your website.
Enabling Web Hosting: Terraform will transform your S3 bucket into a fully functional static website, ready to serve your content to the world. By the end, you’ll have a Terraform script that automates the entire deployment process, saving you time and ensuring a secure and accessible website.

Step 1: Setup Terraform

Create a terraform.tf file to set up the Terraform and provider:

terraform {
 required_version = "1.7.4"
 required_providers {
 aws = {
 source = "hashicorp/aws"
version = "5.40.0"
 }
 }
}
provider "aws" {
 profile = "default"
 region = "ap-south-1"
}

Terraform Configuration Block:
terraform { ... }:This block defines the Terraform configuration itself.
required_version = "1.7.4": Specifies the minimum Terraform version required to run this configuration.
AWS Provider Block:
profile = "default": Uses the default AWS profile configured in your local AWS credentials.
region = "ap-south-1": Specifies the AWS region where your infrastructure will be deployed.

Step 2: Configuration for S3 Bucket:

Create a bucket.tf file to store the Terraform configuration related to the S3 bucket:

resource "aws_s3_bucket" "terraform_demo" {
 bucket = "terraform-demo-43234"
}
resource "aws_s3_object" "terraform_index" {
 bucket = aws_s3_bucket.terraform_demo.id
 key = "index.html"
 source = "index.html"
 content_type = "text/html"
 etag = filemd5("index.html")
}
resource "aws_s3_bucket_website_configuration" "terraform_hosting" {
 bucket = aws_s3_bucket.terraform_demo.id
 index_document {
 suffix = "index.html"
 }
}

Step 3: Configuration for Bucket Policy:

Create a policy.tf file to store the Terraform configuration related to the bucket policy for public access: # S3 public access

resource "aws_s3_bucket_public_access_block" "terraform_demo" {
 bucket = aws_s3_bucket.terraform_demo.id
 block_public_acls = false
 block_public_policy = false
}
resource "aws_s3_bucket_policy" "open_access" {
 bucket = aws_s3_bucket.terraform_demo.id
policy = jsonencode({
 Version = "2012-10-17"
 Id = "Public_access"
 Statement = [
 {
 Sid = "IPAllow"
 Effect = "Allow"
 Principal = "*"
 Action = ["s3:GetObject"]
 Resource = "${aws_s3_bucket.terraform_demo.arn}/*"
 },
 ]
 })
 depends_on = [aws_s3_bucket_public_access_block.terraform_demo]
}

Step 4: Configuration for Output Variable

Create an output.tf file to print out the URL to access the website: Website URL

output "website_url" {
 value = "http://${aws_s3_bucket.terraform_demo.bucket}.s3-
website.${aws_s3_bucket.terraform_demo.region}.amazonaws.com"
}.

Step 5: Initialize Terraform

Open the command prompt or terminal, navigate to the folder where the Terraform file is located, and run the below command:

terraform init

Prepares Terraform’s working directory for managing infrastructure.

Step 6: Terraform Validate

Run the below command to validate the Terraform configuration:

terraform validate

Performs a static analysis of your Terraform configuration files.

Step 7: Terraform Plan

Run the below command to review the intended changes to the infrastructure

terraform plan

Used for understanding and reviewing the intended changes to your infrastructure.

Step 8: Terraform Apply

Run the below command to execute the changes

terraform apply

Executes the actions outlined in the plan generated by the Terraform plan.

Step 9: Destroy:

Run the below command to tear down the infrastructure resources

terraform destroy

The terraform destroy command tears down the infrastructure resources that your Terraform configuration currently manages.

Conclusion:

In this comprehensive guide, we have walked through the process of deploying a static website on
AWS S3 using Terraform. By following the step-by-step instructions outlined above, you can automate
the creation of S3 buckets, effortlessly upload your website files, configure public access policies, and
enable web hosting with ease

AWS EC2 Instance Management with Terraform

Kishore Suzil — Thu, 27 Jun 2024 18:05:34 +0000

Introduction :

Managing infrastructure as code is essential for modern DevOps practices, and Terraform by HashiCorp is a powerful tool for this purpose. In this blog, we will walk through the steps to install Terraform using Chocolatey, and then use Terraform to create, rename, and delete an
AWS EC2 instance. We will also cover using variables and outputs in Terraform.

[Installing Terraform with Chocolatey]
[Setting Up Terraform Configuration]
[Creating an EC2 Instance]
[Renaming an EC2 Instance]
[Deleting an EC2 Instance]
[Using Variables in Terraform]
[Using Outputs in Terraform]
[Conclusion]

Installing Terraform with Chocolatey

Chocolatey is a package manager for Windows that simplifies the installation of software. Follow these steps to install Terraform using Chocolatey:
1. Install Chocolatey:
Open an administrative PowerShell prompt and run the following command:
‘Set-ExecutionPolicy Bypass -Scope Process -Force;
[System.Net.ServicePointManager]::SecurityProtocol =[System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object
System.Net.WebClient).DownloadString('https://community.chocolatey.org/install.ps1'))’

2. Install Terraform
Once Chocolatey is installed, run: powershell choco install terraform

Verify the Installation: Confirm that Terraform is installed by running: powershell “terraform –version” Creating an EC2 Instance Add the following code to main.tf to define an AWS provider and create an EC2 instance:

provider "aws" {
region = "us-east-1"
}
resource "aws_instance" "example" {
ami = "ami-0c55b159cbfafe1f0" # Amazon Linux 2 AMI
instance_type = "t2.micro"
tags = {
Name = "ExampleInstance"
}
}
Initialize Terraform and apply the configuration:
terraform init
terraform apply
Type yes to confirm the apply action. This will create an EC2 instance.

Renaming an EC2 Instance
Renaming an EC2 instance involves changing the Name tag. Modify the tags block in

your main.tf: tags = { Name = "RenamedInstance" } _Apply the changes:_ _terraform apply_ Confirm the changes by typingyes`.

Deleting an EC2 Instance
To delete the EC2 instance, use the destroy command:
terraform destroy
Confirm the destruction by typing yes.
Using Variables in Terraform
Variables allow you to make your Terraform configuration more flexible. Create a variables.tf file:

variable "instance_name" {
description = "Name of the EC2 instance"
type = string
default = "MyInstance"
}
variable "instance_type" {
description = "Type of the EC2 instance"
type = string
default = "t2.micro"
}
Modify main.tf to use these variables:
resource "aws_instance" "example" {
ami = "ami-0c55b159cbfafe1f0"
instance_type = var.instance_type
tags = {
Name = var.instance_name
}
}

Using Outputs in Terraform
Outputs allow you to extract information from your Terraform state. Add the following to

main.tf:
output "instance_id" {
value = aws_instance.example.id
}
output "instance_public_ip" {
value = aws_instance.example.public_ip
}

Apply the configuration:
terraform apply
After the apply is complete, you will see the instance ID and public IP in the output.

Conclusion

In this blog post, we covered how to install Terraform using Chocolatey, and how to use Terraform to create, rename, and delete an EC2 instance. We also explored how to use variables and outputs in Terraform to make your configurations more flexible and extract useful information.By following these steps, you can automate the management of your AWS
infrastructure, making your operations more efficient and reliable. Happy Terraforming.This blog provides a comprehensive guide to getting started with Terraform for managing AWS EC2 instances, with practical steps and code examples

How to Create and Launch an EC2 Instance with IAM Role Attachment Using AWS Instance Connect

Kishore Suzil — Thu, 27 Jun 2024 17:24:56 +0000

Introduction :

AWS EC2 (Elastic Compute Cloud) instances are virtual servers that provide scalable
computing capacity in the cloud. In this use case , we will walk through the steps to create an
EC2 instance, launch it using AWS Instance Connect, and attach an IAM role to the instance.

Prerequisites:

An AWS account.
AWS CLI installed and configured on your local machine.
Necessary permissions to create EC2 instances and IAM roles.

Step 1: Create an IAM Role

1.Navigate to the IAM Console : Open the AWS Management Console and navigate to the
IAM service.
2.Create a New Role : Click on "Roles" in the left sidebar and then "Create role". Select
"AWS service" as the trusted entity type and choose "EC2" for the service that will use this
role. Click "Next: Permissions".
3.Attach Policies : Attach the necessary policies. For example, if you want your instance to
access S3, attach the AmazonS3ReadOnlyAccess policy .Click "Next: Tags" (optional) and
then "Next: Review".
4.Name and Create the Role: Provide a name for the role, such as EC2S3ReadOnlyRole,
and click "Create role".

Step 2: Create an EC2 Instance:

1.Navigate to the EC2 Console: Open the AWS Management Console and navigate to the
EC2 service.
2.Launch an Instance: Click on "Instances" in the left sidebar and then "Launch Instances".
3.Configure Instance Details: Choose an Amazon Machine Image (AMI). For this use case
, we will use the Amazon Linux 2 AMI. And the instance type is ‘t2.micro’ Click "Next:
Configure Instance Details".
4.Attach IAM Role: In the "IAM role" dropdown, select the role you created
earlier(‘EC2S3ReadOnlyRole’).Configure other settings as needed and click "Next: Add
Storage".
5.Add Storage: Specify the storage size and type, then click "Next: Add Tags".
6.Add Tags (optional): Add tags to organize your instances. For example, add a tag with
the key ‘Name’ and value ‘MyEC2Instance’. - Click "Next: Configure Security Group".
7.Configure Security Group: Create a new security group or select an existing one. Ensure
SSH access is allowed from your IP address by adding a rule with the following details:
Type: SSH

Protocol: TCP
Port Range: 22
Source: My IP

8.Review and Launch: Review your instance configuration and click "Launch". Select an
existing key pair or create a new one to connect to your instance and click "Launch
Instances".

Step 3: Connect to the EC2 Instance Using AWS Instance Connect

1.Navigate to the EC2 Console: Go to the EC2 service and click on "Instances".
2.Select Your Instance: Select the instance you just launched.
3.Connect Using AWS Instance Connect: Click on the "Connect" button at the top of the
page. Select "EC2 Instance Connect" and click "Connect".
4.You are now connected to your EC2 instance using AWS Instance Connect!

Conclusion

In this use case , we demonstrated how to create an EC2 instance, attach an IAM role, and
connect to the instance using AWS Instance Connect. This process is essential for securely
managing your AWS resources and leveraging the power of EC2 for scalable cloud
computing

DEV Community: Kishore Suzil

How to Set Up Environment Variables in Docker Containers

How to Set Up Environment Variables in Docker Containers

Step 1: Install Docker

Step 2: Create a Sample Web Application

(A) Create a Project Directory

(B) Initialize a Node.js Project

(C) Install Dependencies

(D) Create server.js File

(E) Add the Following Code in server.js

Step 3: Create a Dockerfile

Step 4: Build and Run the Docker Container (Using -e Flag)

(A) Build the Docker Image

(B) Run the Container with Environment Variables

Step 5: Verify the Running Container

Step 6: Test the Application

Step 7: Use a .env File (Alternative Method)

(A) Create a .env File

(B) Add This Content to .env

(C) Modify docker-compose.yml to Load the .env File

(D) Run the App Using Docker Compose

Step 8: Stopping & Cleaning Up

Final Summary

Scaling Services with Docker Compose

🚀 Scaling Services with Docker Compose

Step 1: Create a Multi-Container Application

Directory Structure

Step 2: Define the Web Service

Dockerfile for the Web Service (web/Dockerfile)

Explanation:

Sample HTML Page (web/index.html)

Step 3: Define docker-compose.yml

Explanation:

Step 4: Configure Load Balancer

Nginx Configuration (nginx.conf)

Step 5: Scale the Service Using Docker Compose

Step 6: Test the Scaled Application

Open your browser and visit:

Check running containers:

How Load Balancing Works

Monitor Docker Logs in Real-Time with a Simple Bash Script

Step 1: Ensure Docker is Installed and Running

Step 2: Create the Log Monitoring Script

Step 3: Grant Execute Permissions

Step 4: Run the Script

Step 5: Check the Log Files

Step 6: Keep Monitoring Logs in Real-Time (Optional)

Step 7: Stop the Script

Automate Docker Container Management with a Simple Bash Script

🛠 Prerequisites

📌 Understanding Key Docker Commands

📝 Writing the Automation Script

✅ Running the Script

Deploying a Static Website on AWS S3 & EC2 Using Terraform" published: true

Deploying a Static Website on AWS S3 & EC2 Using Terraform

What We'll Cover

Prerequisites

Step 1: Configure Terraform & AWS Provider

Step 2: Create an S3 Bucket for Static Website Hosting

Step 3: Configure Public Access Policy

Step 4: Create an EC2 Instance

Step 5: Use Variables & Outputs

Step 6: Deploy with Terraform

Conclusion

🚀 CPU & Memory Monitoring Script

Overview

🛠️ Prerequisites

📝 Bash Script: monitor_usage.sh

🔄 Running the Script

📊 Summary

🚀 Ansible Real-Time Project:

Automating AWS EC2 Management

Overview

🛠️ Prerequisites

📌 Task 1: Create EC2 Instances using Ansible Loops

Playbook: create_instances.yml

Run the playbook:

📌 Task 2: Set Up Passwordless Authentication

Playbook: setup_passwordless_auth.yml

Run the playbook:

(D) Create `server.js` File

(E) Add the Following Code in `server.js`

Step 3: Create a `Dockerfile`

Step 4: Build and Run the Docker Container (Using `-e` Flag)

Step 7: Use a `.env` File (Alternative Method)

(A) Create a `.env` File

(B) Add This Content to `.env`

(C) Modify `docker-compose.yml` to Load the `.env` File

Dockerfile for the Web Service (`web/Dockerfile`)

Sample HTML Page (`web/index.html`)

Step 3: Define `docker-compose.yml`

Nginx Configuration (`nginx.conf`)

📝 Bash Script: `monitor_usage.sh`

Playbook: `create_instances.yml`

Playbook: `setup_passwordless_auth.yml`

Playbook: `shutdown_ubuntu.yml`