DEV Community: kristarking

Deploying an Azure Virtual Machine with Terraform: A Beginner's Guide

kristarking — Mon, 10 Mar 2025 10:23:56 +0000

Introduction
Prerequisites
Installing and Configuring Terraform
Setting Up Your Terraform Project in VS Code
Writing the Terraform Configuration
Initializing and Applying the Terraform Configuration
Retrieving the VM's Public IP and Connecting via SSH
Destroying the VM
Conclusion

Introduction

This guide walks you through the step-by-step process of provisioning Azure resources using Terraform, deploying a virtual machine, retrieving its IP, connecting via SSH, and finally destroying the VM. We'll use VS Code to edit our Terraform scripts for a smooth development experience.

Prerequisites

Before we begin, ensure you have the following installed on your machine:

Terraform (Download here)
Azure CLI (Download here)
VS Code (Download here)
An active Azure subscription

Installing and Configuring Terraform

First, verify that Terraform is installed by running:

terraform -v

If Terraform is not installed, download and install it from Terraform's official site.

az login

Set your default subscription (replace your-sub-id with your actual subscription ID):

az account set --subscription your-sub-id

Setting Up Your Terraform Project in VS Code

Open VS Code
Create a new folder (e.g., azure-terraform-vm)
Open the folder in VS Code
Create a new file named main.tf

Writing the Terraform Configuration

Copy the following Terraform code into main.tf. Replace your-VM-name, your-Vnet-name, etc., with meaningful names of your choice. Don't forget to replace the username and password as well, that's what you will use to SSH into your VM

terraform {
  required_providers {
    azurerm = {
      source  = "hashicorp/azurerm"
      version = "4.3.0"
    }
  }
}

provider "azurerm" {
  features {}
  subscription_id = "your-sub-id"
}

resource "azurerm_resource_group" "your-rg-name" {
  name     = "your-rg-name"
  location = "East US"
}

resource "azurerm_virtual_network" "your-Vnet-name" {
  name                = "your-Vnet-name"
  address_space       = ["10.0.0.0/16"]
  location            = azurerm_resource_group.your-rg-name.location
  resource_group_name = azurerm_resource_group.your-rg-name.name
}

resource "azurerm_subnet" "your-Subnet-name" {
  name                 = "your-Subnet-name"
  resource_group_name  = azurerm_resource_group.your-rg-name.name
  virtual_network_name = azurerm_virtual_network.your-Vnet-name.name
  address_prefixes     = ["10.0.1.0/24"]
}

resource "azurerm_public_ip" "your-ip-name" {
  name                = "your-ip-name"
  location            = azurerm_resource_group.your-rg-name.location
  resource_group_name = azurerm_resource_group.your-rg-name.name
  allocation_method   = "Static"
}

resource "azurerm_network_interface" "your-NIC-name" {
  name                = "your-NIC-name"
  location            = azurerm_resource_group.your-rg-name.location
  resource_group_name = azurerm_resource_group.your-rg-name.name

  ip_configuration {
    name                          = "internal"
    subnet_id                     = azurerm_subnet.your-Subnet-name.id
    private_ip_address_allocation = "Static"
    private_ip_address            = "10.0.1.4"  
    public_ip_address_id          = azurerm_public_ip.your-ip-name.id
  }
}

resource "azurerm_linux_virtual_machine" "your-VM-name" {
  name                  = "your-VM-name"
  location              = azurerm_resource_group.your-rg-name.location
  resource_group_name   = azurerm_resource_group.your-rg-name.name
  size                  = "Standard_B2ms"
  admin_username        = "your-admin-username"
  admin_password        = "YourSecurePassword!"
  network_interface_ids = [azurerm_network_interface.your-NIC-name.id]
  disable_password_authentication = false

  os_disk {
    name              = "your-OsDisk-name"
    caching           = "ReadWrite"
    storage_account_type = "Standard_LRS"
  }

  source_image_reference {
    publisher = "Canonical"
    offer     = "0001-com-ubuntu-server-jammy"
    sku       = "22_04-lts-gen2"
    version   = "latest"
  }
}

output "public_ip_address" {
  description = "The public IP address of the virtual machine"
  value       = azurerm_public_ip.your-ip-name.ip_address
}

Initializing and Applying the Terraform Configuration

Run the following commands in the terminal inside VS Code:

terraform init

terraform plan

terraform apply -auto-approve

Terraform will create all the specified resources in Azure.

Retrieving the VM's Public IP and Connecting via SSH

Get the public IP:

echo $(terraform output -raw public_ip_address)

Use SSH to connect to the VM:

ssh your-admin-username@your-vm-public-ip

Destroying the VM

Once you're done, destroy the VM to avoid unnecessary charges:

terraform destroy -auto-approve

Conclusion

Congratulations! 🎉 You've successfully:

Provisioned Azure resources using Terraform
Deployed a Virtual Machine
Retrieved its IP and connected via SSH
Cleaned up resources by destroying the VM

This is just the beginning of your Terraform journey in Azure! 🚀 Stay tuned for more DevOps guides.

Setting Up Docker on Windows with WSL2

kristarking — Sun, 09 Mar 2025 14:14:13 +0000

If you want to run Docker on Windows efficiently, setting up WSL2 (Windows Subsystem for Linux) is essential. This guide walks you through installing Docker, enabling virtualization, setting up WSL2, and confirming that Docker runs successfully.

Step 1: Install Docker for Windows

First, download and install Docker Desktop for Windows from the official Docker website:

🔗 Download Docker Desktop

Download the Docker Desktop installer.
Run the installer and follow the on-screen instructions.
Ensure "WSL2 Integration" is enabled during the installation process.
Restart your computer if prompted.

Step 2: Enable Virtualization

Before using Docker, ensure that virtualization is enabled on your system.

Press Ctrl + Shift + Esc to open Task Manager.
Navigate to the Performance tab.
Check if Virtualization is enabled.
- If it's disabled, enable it from your system's BIOS settings.

Step 3: Install WSL2

Docker relies on WSL2 for better performance and compatibility. Follow these steps to set it up:

Download the WSL2 Linux kernel update package from the Microsoft website: 🔗 WSL2 Kernel Update
Install the package by following the prompts.
Open Command Prompt as Administrator and run:

   wsl --set-default-version 2

Step 4: Install Ubuntu for WSL2

After enabling WSL2, install a Linux distribution such as Ubuntu.

Open Microsoft Store.
Search for Ubuntu.
Click Get to download and install it.
Launch Ubuntu and complete the initial setup (username & password).

Step 5: Update WSL

To ensure WSL is up to date, run:

wsl --update

This keeps your WSL2 environment optimized for Docker.

Step 6: Run Docker to Confirm It's Working

Open Docker Desktop.
Wait for it to start and ensure there are no errors.
Open Command Prompt or PowerShell, then run:

   docker --version

This should display the installed Docker version.

Test Docker with a simple container:

   docker run hello-world

If everything is set up correctly, Docker will pull and run the test container successfully.

Conclusion

With these steps, you have successfully installed Docker on Windows with WSL2. Now, you can run Linux-based containers seamlessly on your system. 🚀

How to Install and Set Up Terraform on Windows (Step-by-Step Guide)

kristarking — Sat, 08 Mar 2025 13:07:29 +0000

Terraform is a powerful Infrastructure as Code (IaC) tool that allows you to manage cloud resources efficiently. In this guide, we'll walk through installing Terraform on Windows, configuring environment variables, verifying the installation, and creating a simple main.tf file in VS Code.

📌 Table of Contents

Download Terraform
Unzip and Rename the Folder
Move Terraform to Local Disk C
Add Terraform to Environment Variables
Verify Terraform Installation
Create a main.tf File in VS Code

🔹 1. Download Terraform

Open your browser and go to the official Terraform download page.
Scroll down to the Windows section.
Click on the appropriate version (64-bit recommended) to start the download.

🔹 2. Unzip and Rename the Folder

After downloading the Terraform ZIP file:

Locate the downloaded .zip file in your Downloads folder.
Right-click the file and select Extract All…
Rename the extracted folder to terraform.

🔹 3. Move Terraform to Local Disk C

To ensure Terraform is accessible system-wide:

Cut the terraform folder.
Navigate to Local Disk (C:).
Paste the terraform folder inside C:\.

🔹 4. Add Terraform to Environment Variables

To run Terraform commands globally, we need to add it to the system's PATH:

Press Win + R, type sysdm.cpl, and press Enter.
Go to the Advanced tab and click Environment Variables.
Under System Variables, find and select Path, then click Edit.
Click New and enter the Terraform folder path:

   C:\terraform

Click OK on all windows to save the changes.

🔹 5. Verify Terraform Installation

To check if Terraform is installed correctly:

Open Command Prompt (CMD) by pressing Win + R, typing cmd, and hitting Enter.
Run the following command:

   terraform -v

If the installation was successful, you should see the Terraform version displayed.

🔹 6. Create a `main.tf` File in VS Code

Now, let's set up a simple Terraform configuration file:

Open VS Code.
Create a new folder for your Terraform project (e.g., terraform-project).
Inside the folder, create a new file named main.tf.
Open main.tf and add the following sample Terraform configuration:

   terraform {
     required_providers {
       azurerm = {
         source  = "hashicorp/azurerm"
         version = "~> 3.0"
       }
     }
   }

   provider "azurerm" {
     features {}
   }

Save the file.

🎯 Conclusion

Congratulations! 🎉 You have successfully installed Terraform on Windows, configured environment variables, verified the installation, and created your first Terraform configuration file in VS Code.

Now you're ready to start deploying infrastructure using Terraform! 🚀

Let me know in the comments if you encountered any issues! 👇

Advanced Linux Commands Every DevOps Engineer Must Know

kristarking — Sat, 08 Mar 2025 06:58:48 +0000

Linux is the backbone of DevOps. Mastering advanced Linux commands can significantly boost your productivity and troubleshooting skills. This guide covers essential system monitoring, networking, security, automation, and DevOps-specific commands.

📌 Table of Contents

System and Resource Monitoring
Networking and Connectivity
Process and Job Management
Security and User Management
Disk Management and File Operations
DevOps-Specific Commands
Automation and Scheduling

⚙️ 1. System and Resource Monitoring

Monitor system performance and resource usage with these commands:

htop

A more interactive version of top, displaying system resource usage in real-time.

vmstat 1 5

Displays CPU, memory, and I/O statistics every second for five iterations.

iostat -c 2 5

Monitors CPU usage every two seconds, repeated five times.

sar -u 5 5

Collects and reports CPU usage statistics every five seconds.

mpstat -P ALL 5

Displays per-core CPU usage every five seconds.

🌐 2. Networking and Connectivity

Diagnose and debug network issues efficiently:

ss -tulnp

Lists open ports and listening services.

ip route show

Displays the system's routing table.

nmap -sP 192.168.1.0/24

Scans the local network for active devices.

tcpdump -i eth0 port 80

Captures network packets on the eth0 interface for HTTP traffic analysis.

dig example.com +short

Performs a DNS lookup to resolve domain names.

nc -zv google.com 443

Checks if a remote server's port is open.

🔄 3. Process and Job Management

Manage running processes and background jobs:

jobs -l

Lists all background jobs.

fg %1

Brings job number 1 to the foreground.

bg %1

Resumes job 1 in the background.

pkill -f "process_name"

Kills a process by name.

nohup command &

Runs a command even after logging out.

🔒 4. Security and User Management

Enhance system security with these commands:

sudo visudo

Edits the sudoers file securely.

usermod -aG docker username

Adds a user to the docker group.

passwd -l username

Locks a user account.

find / -perm /4000 2>/dev/null

Finds files with the SUID bit set (potential security risks).

history | awk '{print $2}' | sort | uniq -c | sort -nr | head -10

Displays the top 10 most used commands.

💾 5. Disk Management and File Operations

Efficiently manage disk space and files:

lsblk

Lists storage devices and partitions.

mount | column -t

Displays mounted filesystems in a readable format.

du -ah /var/log | sort -rh | head -10

Shows the top 10 largest log files.

rsync -avzh source/ destination/

Syncs files between directories or servers efficiently.

tar -czvf backup.tar.gz /path/to/backup

Compresses a directory into a .tar.gz file.

🚀 6. DevOps-Specific Commands

Essential commands for CI/CD, Docker, Kubernetes, and Terraform:

docker ps -a

Lists all running and stopped Docker containers.

docker images

Displays locally stored Docker images.

kubectl get pods --all-namespaces

Lists all Kubernetes pods across namespaces.

kubectl logs -f pod-name

Streams logs from a Kubernetes pod.

terraform fmt && terraform validate

Formats and validates Terraform configuration.

ansible-playbook -i inventory playbook.yml --check

Runs an Ansible playbook in dry-run mode.

git log --oneline --graph --all

Displays a graphical representation of Git commit history.

🤖 7. Automation and Scheduling

Automate tasks and schedule jobs:

watch -n 5 df -h

Runs df -h every five seconds.

alias ll='ls -lah'

Creates a shortcut for ls -lah.

crontab -l

Lists scheduled cron jobs.

at 10:30 PM tomorrow

Schedules a command to run at a specific time.

🔥 Final Thoughts

Mastering these advanced Linux commands will elevate your DevOps skills, helping you debug issues, automate workflows, and optimize performance.

💬 Which Linux command do you find most useful in your DevOps journey? Let’s discuss in the comments! 🚀

Terraform Import Made Easy: Bring Your Azure Resources Under IaC!

kristarking — Sat, 08 Mar 2025 06:52:16 +0000

Managing cloud resources efficiently is a key skill for DevOps engineers. If you've already created Azure resources manually and want to bring them under Terraform's management, importing them is the way to go. In this guide, I'll walk you through importing an existing Azure Resource Group and Virtual Network into Terraform.

Prerequisites
Set Up Terraform
Initialize Terraform
Import Resource Group
Import Virtual Network
Verify and Manage Resources
Conclusion

Prerequisites

Before we begin, ensure you have the following:

Azure CLI installed and authenticated (az login)
Terraform installed on your machine
Visual Studio Code (VS Code) for writing Terraform configurations
An existing Azure Resource Group and Virtual Network (created manually)

Set Up Terraform

Open Visual Studio Code and create a new directory for your Terraform project.
Inside the directory, create a new file named main.tf and define the provider block for Azure:

   provider "azurerm" {
     features {}
   }

Add the Terraform configuration for your Resource Group and Virtual Network:

   resource "azurerm_resource_group" "KingRG" {
     name     = "KingRG"
     location = "Central US"
   }

   resource "azurerm_virtual_network" "KingVnet" {
     name                = "KingVnet"
     location            = azurerm_resource_group.KingRG.location
     resource_group_name = azurerm_resource_group.KingRG.name
     address_space       = ["10.0.0.0/16"]
   }

Initialize Terraform

Navigate to your Terraform project directory in the terminal and run:

terraform init

This initializes Terraform, downloads required provider plugins, and prepares your project for execution.

Import Resource Group

To import the existing KingRG Resource Group into Terraform state:

Retrieve the resource group’s Azure ID:
- Go to the Azure Portal → Resource Groups → Click on KingRG.
- Select Json Template and copy the id field.

Run the following command to import the resource:

   terraform import azurerm_resource_group.KingRG "/subscriptions/YOUR_SUBSCRIPTION_ID/resourceGroups/KingRG"

Replace YOUR_SUBSCRIPTION_ID with your actual subscription ID.

Verify the import by running:

   terraform state list

Import Virtual Network

Next, import the existing KingVnet Virtual Network:

Retrieve the Virtual Network’s Azure ID:
- Go to the Azure Portal → Virtual Networks → Click on KingVnet.
- Select Jason Template and copy the id field.

Run the following command:

   terraform import azurerm_virtual_network.KingVnet "/subscriptions/YOUR_SUBSCRIPTION_ID/resourceGroups/KingRG/providers/Microsoft.Network/virtualNetworks/KingVnet"

Verify the import:

   terraform state list

Verify and Manage Resources

Now that the resources are imported, run:

terraform plan

This will show any differences between your Terraform configuration and the actual Azure state. If needed, modify main.tf to match the current state of your Azure resources.

To apply any necessary updates, run:

terraform apply

Conclusion

By following this guide, you’ve successfully imported existing Azure resources into Terraform. This allows you to manage them as Infrastructure as Code (IaC), ensuring consistency and automation in your deployments.

The Ultimate Linux Command Guide for DevOps Engineers (With Examples!)

kristarking — Fri, 07 Mar 2025 03:54:22 +0000

As a DevOps engineer, mastering Linux commands is crucial for managing servers, automating deployments, troubleshooting issues, and handling infrastructure efficiently. This guide covers essential Linux commands that every DevOps engineer should know.

File and Directory Management
User and Permission Management
Process Management
Networking Commands
Disk and Storage Management
System Monitoring and Performance Tuning
Package Management
Logging and Troubleshooting
Automation and Scheduling

1. File and Directory Management

Print Working Directory

pwd

Displays the current working directory.

List Files and Directories

ls -lah

-l: Long listing format.
-a: Show hidden files.
-h: Human-readable file sizes.

Change Directory

cd /path/to/directory

Move into a specified directory.

Create a Directory

mkdir new_directory

Creates a new directory.

Create an Empty File

touch filename

Creates an empty file.

Write to a File

echo 'Hello, World!' > filename

Writes 'Hello, World!' into a file (overwrites content).

Append Text to a File

echo 'New Line' >> filename

Appends 'New Line' to an existing file.

Open a File for Editing

nano filename

Opens the file in the nano text editor.

Remove a File or Directory

rm -rf file_or_directory

-r: Remove directories and their contents.
-f: Force delete without confirmation.

Copy and Move Files

cp source_file destination
mv source_file destination

cp: Copies a file or directory.
mv: Moves (or renames) a file or directory.

2. User and Permission Management

Check Current User

whoami

Displays the current logged-in user.

Add a New User

sudo useradd -m username

-m: Creates a home directory for the user.

Change File Permissions

chmod 755 filename

7: Read, write, and execute for the owner.
5: Read and execute for group and others.

Change File Ownership

sudo chown user:group filename

chown: Change ownership of a file or directory.

3. Process Management

View Running Processes

ps aux

Displays all running processes.

Kill a Process

kill -9 process_id

-9: Forcefully terminates a process.

Monitor System in Real Time

top

Displays system resource usage.

4. Networking Commands

Check Network Interfaces

ip a

Displays IP addresses and network interfaces.

Test Connectivity

ping google.com

Sends ICMP echo requests to check connectivity.

Check Open Ports

netstat -tulnp

Lists open ports and their associated processes.

5. Disk and Storage Management

Check Disk Usage

df -h

Displays disk space usage in a human-readable format.

Check Directory Size

du -sh /path/to/directory

-s: Summarizes the total size.
-h: Human-readable format.

6. System Monitoring and Performance Tuning

View System Uptime

uptime

Shows how long the system has been running.

Check Memory Usage

free -m

Displays memory usage in megabytes.

Monitor Logs in Real Time

tail -f /var/log/syslog

Displays live updates from a log file.

7. Package Management

Install a Package (Debian-based)

sudo apt install package_name

Install a Package (Red Hat-based)

sudo yum install package_name

Remove a Package

sudo apt remove package_name

8. Logging and Troubleshooting

Check System Logs

journalctl -xe

Displays system logs with detailed errors.

View Authentication Logs

cat /var/log/auth.log

Shows login attempts and authentication logs.

9. Automation and Scheduling

Schedule a Cron Job

crontab -e

Opens the crontab file for scheduling tasks.

Example Cron Job (Runs every day at 2 AM):

0 2 * * * /path/to/script.sh

Conclusion

Mastering these Linux commands will significantly improve your efficiency as a DevOps engineer. Whether managing servers, troubleshooting issues, or automating tasks, these commands form the foundation of your daily operations.

Which command do you use the most? Let me know in the comments!

How to Set Up Nginx & SSL for Your JavaScript App on Azure VM : A Beginner’s Guide

kristarking — Thu, 06 Mar 2025 13:19:00 +0000

Table of Contents

Setting Up an Azure Virtual Machine Creating the VM Connecting to Your VM
Updating the System and Installing Essential Packages
Setting Up a Firewall
Installing and Configuring Nginx Installing Nginx Allowing Web Traffic
Deploying Your JavaScript Application Navigating to the Web Root Directory Cloning Your Application from GitHub Setting Proper File Permissions
Configuring Nginx for Your Application Enabling the Configuration
Setting Up SSL with Certbot Installing Certbot Enabling Auto-Renewal
Final Security Configurations
Conclusion

When building a web application, ensuring it is properly deployed and secured is crucial. In this guide, I will walk you through deploying a JavaScript application on an Azure Virtual Machine (VM) using Nginx as a web server. This guide is beginner-friendly, ensuring that even if you are new to cloud computing, you can follow along and get your application live on the internet with a secure SSL certificate that auto-renews and map the VM's public IP address to a domain name, ensuring that users can access your application through a custom domain instead of an IP address.

First, let's get an application to work with, Google search a JS app on github

Step 1: Setting Up an Azure Virtual Machine

Creating the VM
To begin, log in to your Azure portal and navigate to Virtual Machines. Click Create > Azure Virtual Machine and provide the necessary details:

Image: Choose Ubuntu 22.04 LTS (or a later version for the latest security updates).
Size: Select a VM size based on your application’s resource requirements.
Authentication Type: Choose SSH Public Key for security.
Networking: Ensure SSH (port 22, Port 80 and Port 443) is allowed so you can connect remotely.

Once all configurations are set, click Create and wait for deployment to complete. Afterward, go to the VM Overview section to copy the Public IP Address—this will be needed to connect to the VM.

Connecting to Your VM

To access your virtual machine, open a terminal (or Command Prompt if on Windows) and use SSH to connect:

ssh user@your_vm_ip

Replace your_vm_ip with the actual public IP address of your VM. Once connected, you are inside your server and ready to begin setup.

Step 2: Updating the System and Installing Essential Packages

Before deploying your application, it is best to update the system to ensure everything runs smoothly:

sudo apt update && sudo apt upgrade -y

This command updates the package list and installs any available upgrades.

Next, install essential packages needed for deployment:

sudo apt install -y git curl ufw

git allows you to clone your application from GitHub.
curl helps with downloading files and checking connections.
ufw is the Uncomplicated Firewall tool for securing your server.

Step 3: Setting Up a Firewall

To protect your VM, configure a firewall to allow only necessary traffic.

Enable OpenSSH access so you don’t get locked out:

sudo ufw allow OpenSSH

Then enable the firewall:

sudo ufw enable

Your firewall is now protecting your server while still allowing SSH access.

Step 4: Installing and Configuring Nginx

Nginx is a powerful web server that will serve your JavaScript application.

Installing Nginx

To install Nginx, run:

sudo apt install -y nginx

After installation, start the Nginx service:

sudo systemctl start nginx

To check if it is running correctly:

systemctl status nginx

If everything is set up properly, you should see a message indicating that Nginx is active.

Allowing Web Traffic

Now, update the firewall rules to allow web traffic:

sudo ufw allow 'Nginx Full'

This ensures users can access your site via HTTP and HTTPS.

Step 5: Deploying Your JavaScript Application

Your application files must be placed in the web server's root directory. To do this:

Navigating to the Web Root Directory

Move into the Nginx directory where website files are stored:

cd /var/www

Cloning Your Application from GitHub

Use git to pull your project from GitHub:

sudo git clone your-git-repo

Rename the folder to your preferred website name:

sudo mv devportfolio your-web-name (In my case, I'm using heros)

This means your application will be served from /var/www/heros.

Setting Proper File Permissions

Adjust permissions to ensure Nginx can serve the files correctly:

sudo chown -R www-data:www-data /var/www/heros
sudo chmod -R 755 /var/www/heros

This allows Nginx to read and serve the files while keeping them secure.

Step 6: Configuring Nginx for Your Application

Create a new configuration file for your application:

sudo nano /etc/nginx/sites-available/heros

Inside the file, add:

server {
    listen 80;
    server_name heros.com.ng www.heros.com.ng;

    root /var/www/heros;
    index index.html;

    location /.well-known/acme-challenge/ {
        root /var/www/heros;
    }
}

This tells Nginx to serve your application from /var/www/heros and listen on port 80.

Save and close the file.

Enabling the Configuration

Create a symbolic link to enable your new Nginx configuration:

sudo ln -s /etc/nginx/sites-available/heros /etc/nginx/sites-enabled/

Test the Nginx configuration:

sudo nginx -t

If there are no errors, reload Nginx:

sudo systemctl reload nginx

Step 6b: Map your public IP to your domain name. Domain name providers are different, if you don't know how to map your IP to your domain name, contact your domain name provider, to email you the step-by-step guide to do that. In my case, I'm using smartweb as my domain name provider

Step 7: Setting Up SSL with Certbot

Securing your site with HTTPS is critical. We will use Certbot to obtain and automatically renew an SSL certificate.

Installing Certbot

First, install Certbot:

sudo snap install certbot --classic

Then, obtain and install the SSL certificate:

sudo certbot --nginx -d heros.com.ng -d www.heros.com.ng

Certbot will automatically configure your Nginx settings for SSL.

Enabling Auto-Renewal

Certbot automatically renews certificates, but we can verify by running a test renewal:

sudo certbot renew --dry-run

This ensures your SSL certificate will renew without issues.

Step 8: Final Security Configurations

Re-enable the firewall with all necessary rules:

sudo ufw enable

Your application should now be live at:

https://heros.com.ng

By following this guide, you have successfully deployed a JavaScript application on an Azure VM with Nginx and SSL. You now have a fully functional and secure web application. Additionally, we have mapped the VM's public IP address to a domain name, ensuring that users can access your application through a custom domain instead of an IP address.

If you found this guide helpful, share your thoughts in the comments!

Happy coding! 🚀

Deploying a Go Web App on Azure Container Instances with ACR

kristarking — Tue, 04 Mar 2025 13:01:08 +0000

Table of Contents
Introduction
Requirements
Step 1: Writing the Go Web App
Step 2: Creating the Dockerfile
Step 3: Building and Running the Docker Container Locally
Step 4: Setting Up Azure Container Registry (ACR)
Step 5: Pushing the Docker Image to ACR
Step 6: Deploying the Container to Azure Container Instances (ACI)
Step 7: Accessing the Deployed App
Conclusion

Introduction
Cloud-native applications are revolutionizing the way we deploy and scale software. In this guide, we will build a simple Go-based web app, containerize it using Docker, push the image to Azure Container Registry (ACR), and finally deploy it on Azure Container Instances (ACI).

By the end, you will have a fully functional cloud-hosted app running on Azure.

Requirements

Before we begin, ensure you have the following:

✅ Azure CLI installed → Install Azure CLI
✅ Docker installed → Install Docker
✅ Go installed → Install Go
✅ An Azure Subscription (Create one at Azure Portal

Step 1: Writing the Go Web App
First, create a new directory and navigate into it: Open any terminal you have use this command

mkdir go-app && cd go-app

Now, open your VS code and create a file name _main.go _and add the following Go code:

package main

import (
    "fmt"
    "net/http"
    "os"
)

func main() {
    version := os.Getenv("VERSION")
    if version == "" {
        version = "v1" // Default version
    }

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, `<html>
        <head>
            <title>Cloud DevOps in Action</title>
            <style>
                body { font-family: Arial, sans-serif; text-align: center; margin-top: 50px; }
                h1 { color: #2c3e50; }
                h2 { color: #16a085; }
                p { color: #7f8c8d; font-size: 18px; }
            </style>
        </head>
        <body>
            <h1>🚀 Welcome to Cloud DevOps in Action! 🌍</h1>
            <h2>Continuous Deployment. Scalable. Resilient.</h2>
            <p>Empowering developers and businesses with automated deployments.</p>
            <p>Running Version: %s</p>
            <p>🔹 Powered by Containers | Kubernetes | GitHub Actions | Azure 🔹</p>
            <p><i>Stay ahead in the cloud revolution! 🚀</i></p>
        </body>
        </html>`, version)
    })

    http.HandleFunc("/version", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "App Version: %s\n", version)
    })

    http.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "System Status: Healthy ✅\n")
    })

    fmt.Println("Server running on port 80...")
    http.ListenAndServe(":80", nil)
}

Step 2: Creating the Dockerfile
Next, create a Dockerfile in the same directory:

FROM golang:alpine AS builder

ARG VERSION
ENV VERSION=${VERSION:-v2}

WORKDIR /app
COPY main.go .
RUN go build -o app main.go

FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/app .

EXPOSE 80
CMD ["./app"]

Step 3: Building and Running the Docker Container Locally
To build the Docker image, run:

docker build -t your-image-name:tag .

In my case, I'm using goapp as my image name and v1 as my tag

If you have an error like this, don't panic, just open your _Docker Desktop _ then run the command again

Step 4: Setting Up Azure Container Registry (ACR)
Create an Azure Container Registry (ACR):
Go to Azure console, search for Container Registry

Click Create
Fill in the details:
Subscription: Your Azure Subscription
Resource Group: Create a new one (e.g., goappRG)
Registry Name: A unique name (e.g., kingacr)
Region: Choose a location eg, (Central US)
SKU: Choose Basic (cheapest option) Click Review + Create → Click Create

Enable Admin Access
Go to your newly created ACR, under "review"
Click Access Keys
Turn on Admin User

Step 5: Uploading the Docker Image to ACR
Log in to ACR from Docker using this command

az acr login --name youracrname
docker build . -t youracr.azurecr.io/your-image-name:v1

In my case I'm using goapp as image name and my ACR is kingacr
Push the Image to ACR

docker push youracr.azurecr.io/your-image-name:v1

Step 6: Deploying the Container to Azure Container Instances (ACI)
Go to Azure Portal
Search for Container Instances

Configure ACI Deployment
Resource Group: e.g goappRG
Container Name:e.g cloud-devops-container
Region: Same as ACR
Image Source: Select Azure Container Registry
Registry Name: kingacr
Image: e.g go-app
OS Type: Linux
CPU: 1
Memory: 1GB
Port: 80
Click Review + Create → Create

Step 7: Accessing the Deployed App
Go to Container Instances
Copy the Public IP Address

Open the App in Your Browser
Visit: http://

Conclusion

In this guide, we walked through the entire process of building, containerizing, and deploying a Go web application using Azure Container Registry (ACR) and Azure Container Instances (ACI)—all through the Azure Portal without needing complex CLI commands.

🌟 What You Achieved Today:
✅ Developed a simple yet powerful cloud-native Go application
✅ Containerized the app using Docker for seamless portability
✅ Configured and pushed the image to Azure Container Registry (ACR)
✅ Deployed it as a fully managed container instance (ACI)
✅ Accessed the live application via a public endpoint

How to Host a Static Website on Azure Storage

kristarking — Sat, 01 Mar 2025 08:45:22 +0000

Introduction
Want to host a website without managing servers? Azure Storage Static Website Hosting is an easy, fast, and cost-effective way to deploy a website without worrying about infrastructure.

In this step-by-step guide, I’ll show you how to:
✅ Create an Azure Storage Account
✅ Enable Static Website Hosting
✅ Upload your website files
✅ Access your live website

By the end, you’ll have a fully functional static website running on Azure!

Table of Contents
1 Prerequisites
2 Step 1: Create an Azure Storage Account
3 Step 2: Enable Static Website Hosting
4 Step 3: Upload Website Files to Azure Storage
5 Step 4: Access Your Website
6 Conclusion

Prerequisites
Before starting, make sure you have:

✅ An Azure account (Sign up here if you don’t have one).
✅ A simple static website (at least an index.html file).

Create an Azure Storage Account
1.1 – Log in to Azure Portal
Visit the Azure Portal.
Sign in with your Microsoft account.
1.2 – Create a Storage Account
Click "Create a resource".
Search for "Storage Account" and select "Create".

1.3 –** Configure Storage Account Settings**
Fill in these details:

Subscription: Select your active subscription.
Resource Group: Choose an existing one or create a new one.
Storage Account Name: Enter a unique name (e.g., mystaticweb).
Region: Choose a data center close to your audience.
Performance: Select Standard.

You can leave anonymous access as it is, cause I will show you how to fix it

Review & Create
Click "Review + Create".
Click "Create" and wait for deployment.

Once done, click "Go to resource".

Your Azure Storage Account is now set up!

Create a container, give it a name, then click on "Create"

click on the container name you just created, then click on "upload"
3.2 – Upload Your Files
Click "Upload".
Select your HTML, CSS, JavaScript, and image files.
Click "Upload" to confirm.
✅ Your website files are now hosted on Azure!

Step 4: Access Your Website
After uploading your website files, click on the container name you created, then you will have URL to your website, copy the URL

ERROR!
Access denied issue, do not worry, I will show you how to access it

To fix this, under "overview" scroll, click on "Configuration" Enable "Allow Blob anonymous access" then click on save

Go back to the container you created, click on the three dots (...) change the access level

Refresh the website URL

Your website should now be visible!

Your static website is now live!

If your website doesn’t load:

Ensure index.html is uploaded correctly.
Clear browser cache or open in Incognito Mode.

Conclusion
Congratulations! 🎉 You’ve successfully hosted a static website on Azure Storage in just a few steps.

What We Achieved:
✅ Created an Azure Storage Account.
✅ Enabled Static Website Hosting.
✅ Uploaded our website files.
✅ Accessed the website via Azure’s public URL.

Deploying a JavaScript Application on Azure: Beginner's Guide

kristarking — Thu, 27 Feb 2025 12:00:41 +0000

This guide will walk you through the process of deploying a JavaScript digital clock application on Microsoft Azure. We'll cover everything from setting up your development environment to creating a load balancer, highly available web application. Don't worry if you're new to cloud computing or Azure - we'll explain each concept as we go along.

Table of Contents

Understanding Azure
Setting Up Your Development Environment
Preparing Your Application
Creating Azure Resources
Deploying Your Application
Implementing Load Balancing
Testing and Verification

Understanding Azure
Microsoft Azure is a cloud computing platform that provides a wide range of services for building, deploying, and managing applications. Here are some key concepts you'll need to understand:
● Resource Group: A container that holds related resources for an Azure solution.
● Virtual Network (VNet): A representation of your own network in the cloud.
● Subnet: A range of IP addresses in your VNet.
● Virtual Machine (VM): A computer file (image) that behaves like an actual computer.
● Load Balancer: A service that distributes incoming network traffic across multiple
servers.

Setting Up Your Development Environment
Install Visual Studio Code:
● Download and install Visual Studio Code (VS Code) from https://code.visualstudio.com/
● VS Code is a lightweight but powerful source code editor that we'll use to manage our application code.
Create a GitHub Account:
● Go to https://github.com/ and sign up for an account if you don't already have one.
● GitHub is a platform for hosting and collaborating on code repositories

Preparing Your Application
Find a JavaScript Digital Clock Application:
● Search for a simple JavaScript digital clock application online.
● Download and unzip the application to your local computer.

Set Up a GitHub Repository
Log in to GitHub and create a new repository.
Follow the instructions provided by GitHub to initialize the repository.

Moved the code to Visual Studio Code
VS Code provides a powerful environment for code, version control, and terminal access.
Unzip the downloaded file and Push the JavaScript code from the local computer to a GitHub repository

Push Your Code to GitHub Open VS Code and open the folder containing your JavaScript application.
Open the integrated terminal in VS Code.
Initialize a Git repository, add your files, commit the changes, and push to GitHub using these commands:
git init
git add .
git commit -m "Initial commit"
git remote add origin
git push -M master

Creating Azure Resources
Sign Up for Azure:
Go to portal.azure.com and sign up for an account.

Create a Resource Group:
● Once logged into the Azure portal, click "Create a resource" in the top left.
● Search for "Resource group" and click "Create".
● Give it a name (e.g., "JS-Clock-RG") and choose a region close to you.
● Click "Review + create", then "Create".
Create a Virtual Network (VNet):
● In the Azure portal, search for "Virtual network" and click "Create".
● Select your resource group.
● Give it a name (e.g., "JS-Clock-VNet").
● Keep the default settings for address space and subnet.
● Click "Review + create", then "Create".

Creating and Configuring the Virtual Machine
● On the Azure portal, search for "Virtual machine" and click "Create".
● Select your resource group.
● Give your VM a name (e.g., "JS-Clock-VM1").
● Choose "Ubuntu Server" as the image.
● Choose a size (B1s is sufficient for this project).
● Set up a username and password.
● Under ports open port 22 (SSH) and 80 (HTTP).
● And Make sure everything is deployed in the same region
● Click "Review + create", then "Create".

Setting up the Azure infrastructure correctly is crucial for security, scalability, and manageability. The Resource Group helps organize related resources for easier management. The VNet and Subnet provide network isolation, enhancing security by controlling traffic flow between Azure resources and the internet. Creating a VM gives you full control over the server environment, allowing you to install and configure software as needed. Opening specific ports is a security best practice -port 22 for SSH access ensures secure remote management, while port 80 allows HTTP traffic to reach your web application.

Copy IP address from VM
After the creation of the Virtual Machine, A public IP address will be given to the Virtual Machine machine, this will allow us to SSH into the VM

Application Deployment

SSH into the VM (Secure Shell (SSH) provides encrypted communication for secure remote access to the VM)

ssh -i username@ip address

Install NGINX web server
NGINX is a high-performance web server that can efficiently serve static content and proxy requests to application servers. Once connected to your VM, run these commands:
sudo apt update
sudo apt install nginx -y

You can “curl ip” to be sure Nginx is on the IP

Test Nginx In Working: Copy your Virtual Machine public IP to your browser

Configure NGINX
Navigate to the NGINX configuration directory
The command:** cd /etc/nginx**
This directory contains NGINX configuration files.
Then type _ls _command to list nginx files

Removed existing NGINX configuration files
This ensures a clean slate for your custom configuration, preventing conflicts with default settings.
Remove the default configuration with the command: sudo rm -r (add default file names from nginx to be removed, you can add all files at once like I did in the
picture below)

Deploy Your Application
Clone your GitHub repository: git clone
https://github.com/your-username/your-repo-name.git
Then use this command: sudo cp -r reponame/* /var/www/html

Verify Your deployment via the VM's public IP address
Go back to your VM's overview page in the Azure portal.
Copy the public IP address.
Open a new browser tab and paste in the IP address.
You should see your JavaScript clock running!

Creating a VM Image
Stop the VM:
● In the Azure portal, go to your VM's overview page.
● Click "Stop".
Create an Image:
● Once the VM is stopped, click "Capture" in the top menu.
● Give your image a name (e.g., "JS-Clock-Image").
● Choose to create the image in your resource group.
● Give the version “1,0.0
● Select “Delete the original VM
● Click "Review + create", then "Create"

Created a Bastion host for secure access to private VM
Go to the Azure search box type in “Bastion” select the right region, leave instance count at 2. Click on “review and create”
Bastion provides a secure way to access your private VMs without exposing them directly to the internet.

Use The Bastion To Access The VM
Under overview, click on “Bastion” put the VM username and password or select
the right key pair.
Click on “Connect”

Deploy Multiple private VMs using the same image
Create Private VMs:
● Create 4 new VMs using the image you just created.
● When creating each VM, make sure to:
○ Place it in the same resource group and VNet.
○ Do not assign a public IP address (this makes it a private VM).
● Name these VMs "JS-Clock-VM1", "JS-Clock-VM2", "JS-Clock-VM3", and
"JS-Clock-VM4".

Setting Up Load Balancing
Load balancing distributes incoming traffic across multiple VMs, improving
performance and availability.
In the Azure portal, search for "Load Balancer" and click "Create".
Choose the "Public" type.
Select your resource group.
Give it a name (e.g., "JS-Clock-LB").
Click "Next”

Configure the Load Balancer
Next to “Front end ip address” give your ip a name
Under "Backend pools" add all four of your VMs to this backend pool.
Under "Settings", click "Health probes" and create a new one:
● Protocol: HTTP
● Port: 80
Under "Settings", click "Load balancing rules" and create a new one:
● Protocol: TCP
● Port: 80
● Backend port: 80
● Backend pool: The one you just created
● Health probe: The one you just created

Add the Load Balancing rule

Added all four private VMs to the load balancer
● Reason: This allows the load balancer to distribute traffic among all your
application servers.

Implementing a load balancer is crucial for high availability and performance. It evenly distributes incoming requests across your VMs, preventing any single VM from becoming overwhelmed. This setup also provides fault tolerance - if one VM fails, the others can continue serving requests. The load balancer's public IP becomes the sole entry point to your application.

Open port 80 (HTTP)

Test Your Load-Balanced Application
Go to your load balancer's overview page.
Copy the public IP address.
Open a new browser tab and paste in the IP address.
You should see your JavaScript clock running!

The digital clock application is now accessible through the load balancer's public IP Traffic is distributed across four private VMs
The Javascript Application (Digital Clock) Is Now Accessible

The digital clock application is accessible through the load balancer's public IP Traffic is distributed across four private VMs
Testing Load Balancer Functionality
Stop Two VMs:
● In the Azure portal, go to the overview pages for two of your VMs.
● Click "Stop" for each of them.
Verify Application Availability:
● Refresh the browser tab with your application.
● It should still be working, demonstrating that the load balancer is routing traffic to the
remaining active VMs.

Expected Outcome
The Load Balancer should automatically detect that the two VMs are unavailable.
It should continue to distribute incoming traffic to the remaining available VMs. Users accessing the application via the Load Balancer's IP should still see the
JavaScript application running seamlessly.

Results
The Load Balancer successfully detected the stopped VMs.
It rerouted traffic to the available VMs, ensuring continuous availability of the JavaScript application

Congratulations! You've successfully deployed a JavaScript application on Azure with load balancing capabilities. This setup ensures high availability of your application, as it continues to function even if some servers go down

Conclusion
This demonstrates a comprehensive approach to deploying a web
application on Azure, utilizing various services to create a scalable, secure, and highly available infrastructure. that the Azure Load Balancer is functioning correctly, providing high availability and fault tolerance by distributing traffic to active VMs. This setup ensures that even if some VMs go offline, the application remains accessible to users.

DEV Community: kristarking

Deploying an Azure Virtual Machine with Terraform: A Beginner's Guide

Table of Contents

Introduction

Prerequisites

Installing and Configuring Terraform

Setting Up Your Terraform Project in VS Code

Writing the Terraform Configuration

Initializing and Applying the Terraform Configuration

Retrieving the VM's Public IP and Connecting via SSH

Destroying the VM

Conclusion

Setting Up Docker on Windows with WSL2

Step 1: Install Docker for Windows

Step 2: Enable Virtualization

Step 3: Install WSL2

Step 4: Install Ubuntu for WSL2

Step 5: Update WSL

Step 6: Run Docker to Confirm It's Working

Conclusion

How to Install and Set Up Terraform on Windows (Step-by-Step Guide)

📌 Table of Contents

🔹 1. Download Terraform

🔹 2. Unzip and Rename the Folder

🔹 3. Move Terraform to Local Disk C

🔹 4. Add Terraform to Environment Variables

🔹 5. Verify Terraform Installation

🔹 6. Create a main.tf File in VS Code

🎯 Conclusion

Advanced Linux Commands Every DevOps Engineer Must Know

📌 Table of Contents

⚙️ 1. System and Resource Monitoring

🌐 2. Networking and Connectivity

🔄 3. Process and Job Management

🔒 4. Security and User Management

💾 5. Disk Management and File Operations

🚀 6. DevOps-Specific Commands

🤖 7. Automation and Scheduling

🔥 Final Thoughts

Terraform Import Made Easy: Bring Your Azure Resources Under IaC!

Table of Contents

Prerequisites

Set Up Terraform

Initialize Terraform

Import Resource Group

Import Virtual Network

Verify and Manage Resources

Conclusion

The Ultimate Linux Command Guide for DevOps Engineers (With Examples!)

Table of Contents

1. File and Directory Management

Print Working Directory

List Files and Directories

Change Directory

Create a Directory

Create an Empty File

Write to a File

Append Text to a File

Open a File for Editing

Remove a File or Directory

Copy and Move Files

2. User and Permission Management

Check Current User

Add a New User

Change File Permissions

Change File Ownership

3. Process Management

View Running Processes

Kill a Process

Monitor System in Real Time

4. Networking Commands

Check Network Interfaces

Test Connectivity

Check Open Ports

5. Disk and Storage Management

Check Disk Usage

Check Directory Size

6. System Monitoring and Performance Tuning

View System Uptime

Check Memory Usage

🔹 6. Create a `main.tf` File in VS Code