Google Drive is great — until you need to manage files on a remote server, automate uploads in a script, or just prefer working in a terminal. The web UI doesn't help when you're SSH'd into a Linux box, and the official desktop client isn't designed for automation or headless environments.

That's why I built DriveCLI — a single-binary command-line tool that brings Google Drive directly into your terminal. No installation wizards, no runtime dependencies, no GUI required.

What Is DriveCLI?

DriveCLI is an open-source Google Drive CLI written in C# on .NET 9. It compiles to a single self-contained executable that runs on Windows, Linux, and macOS — you just download one file and start using it.

It covers the operations you use most:

• Authentication — OAuth 2.0 with browser-based and manual code-paste flows

• Browse & Search — List folders, search files by name or MIME type

• Upload & Download — With real-time progress bars, transfer speed, and ETA

• File Management — Move, rename, trash, permanently delete, and share files

• Background Transfers — Uploads and downloads continue even if you close the terminal

Key Features

Single Binary, Zero Dependencies

DriveCLI ships as one executable file. There's no .NET runtime to install, no package manager to configure. Download it, put it on your PATH, and you're ready to go.

Works Over SSH and Headless Servers

DriveCLI auto-detects headless environments (no display server, SSH sessions, containers) and switches to a manual code-paste authentication flow. You can authenticate from any device with a browser — even your phone — and paste the code back into your terminal.

drivecli login --manual

Resumable Uploads

Large file uploads use Google Drive's resumable upload protocol, sending data in 1 MB chunks. If the connection drops, the upload can resume from where it left off instead of starting over.

MD5 Integrity Verification

Every file transfer — upload or download — is verified against Google Drive's stored MD5 checksum. If something goes wrong during transfer, you'll know immediately.

Background Transfers

When you start an upload or download, DriveCLI spawns a background worker process. Press Ctrl+C or close the terminal, and the transfer keeps running. Check on it anytime:

drivecli ps           # List all active transfers
drivecli ps aae34     # Inspect a specific transfer
drivecli ps-stop aae34  # Cancel a transfer

Rich Terminal UI

Built with Spectre.Console, DriveCLI renders formatted tables, progress bars with speed and ETA, icons, and colour — making the terminal experience pleasant and informative.

JSON Output for Scripting

Every listing command supports --json output, making it easy to pipe results into jq, scripts, or other tools:

drivecli ls --json | jq '.[].name'
drivecli find "report" --json

Quick Start

1. Set Up Google Cloud Credentials

1. Go to the Google Cloud Console

2. Create a project and enable the Google Drive API

3. Create an OAuth 2.0 Desktop client credential

4. Copy the Client ID and Client Secret

2. Install DriveCLI

Download the binary for your platform from the GitHub releases page and add it to your PATH.

Or build from source:

git clone https://github.com/bishojit/DriveCLI.git
cd DriveCLI
dotnet build

3. Sign In

drivecli login

Enter your Client ID and Secret when prompted. Your browser opens for Google authorization. Once approved, you're authenticated — no need to log in again unless you explicitly log out.

4. Start Using It

# List your Drive files
drivecli ls

# Search for a file
drivecli find "quarterly-report"

# Upload a file
drivecli upload ./presentation.pptx

# Upload an entire folder
drivecli upload ./project-files --recursive

# Download a file
drivecli download FILE_ID --output ./downloads

# Share a file
drivecli share FILE_ID

Full Command Reference

Built With

Who Is This For?

• Developers who manage files on remote servers via SSH

• DevOps / SysAdmins who need automated Drive backups or deployments

• Power users who prefer the terminal over browser-based file management

• Anyone who wants a lightweight, portable Google Drive client without heavy desktop apps

Open Source

DriveCLI is open source under the MIT License. Contributions, issues, and feature requests are welcome.

• GitHub: https://github.com/bishojit/DriveCLI

What's Next?

I'm actively working on DriveCLI and plan to add more features based on community feedback. If you have ideas or run into issues, feel free to open an issue on GitHub.

Give it a try, and let me know what you think!

🏢 About Bikiran

Bikiran is a software development and cloud infrastructure company founded in 2012, headquartered in Khulna, Bangladesh. With 15,000+ clients and over a decade of experience, Bikiran builds and operates a suite of products spanning domain services, cloud hosting, app deployment, workflow automation, and developer tools.

What is IMAP?

IMAP allows you to access emails directly on the mail server. When you read, move, or delete an email in your client (like Outlook, Thunderbird, or a mobile app), those actions are reflected on the server and thus on all other devices accessing that account.

Key Features of IMAP

• Synchronizes emails across all devices

• Emails stored on the server: No need to worry about losing messages if your device fails

• Folders and organization: Create, rename, and delete folders that sync everywhere

• Partial downloads: Quickly preview emails without downloading attachments

What is POP3?

POP3 downloads emails from the server to your device and often removes them from the server (though some clients let you leave a copy on the server). Your email client becomes the main (sometimes only) place to store your messages.

Key Features of POP3

• Emails stored locally: Once downloaded, emails are on your device

• Limited server storage needs

• No synchronization of read/unread status or folders across devices

• Ideal for single-device access: Not recommended if you check mail on multiple devices

IMAP vs. POP3: Feature Comparison

Which Protocol Should You Use?

Recommended: IMAP

• Best for: Anyone who uses multiple devices (phone, tablet, laptop, webmail)

• Why: Keeps your inbox organized and consistent everywhere. If you lose a device, your emails are still safe on the server.

When to Use POP3

• Best for: Users with limited server storage or those who only check email on one device

• Why: Downloads and removes emails from the server, freeing up server space. However, you risk losing emails if your device fails.

How to Configure IMAP and POP3

Below are general settings for most email providers. Always check your provider's help pages for specifics.

IMAP Configuration

POP3 Configuration

Outgoing (SMTP) Configuration (For Both)

Step-by-Step Guide: Setting Up in Outlook

1. Open Outlook and go to File > Account Settings > Add Account.

2. Choose Manual setup or additional server types.

3. Select IMAP or POP according to your preference.

4. Enter your name and email address.

5. For Incoming mail server, enter the IMAP or POP3 server (see configuration tables above).

6. For Outgoing mail server (SMTP), enter the SMTP server.

7. Enter your full email address as the username and your password.

8. Click More Settings:

   • Under the Outgoing Server tab, check “My outgoing server (SMTP) requires authentication.”

   • Under the Advanced tab, enter the correct ports and select SSL/TLS as the encryption type.

9. Click OK, then Next to test the settings.

10. Click Finish if the test is successful.

Summary

• IMAP is recommended for most users, especially if you use multiple devices.

• POP3 is suitable for users needing local storage or with limited server space.

• Always use secure ports and encryption (SSL/TLS) for safety.

• Double-check your provider’s documentation for server addresses and settings.

If you have any questions or need help troubleshooting your mail setup, leave a comment below!

CONTACT:

I’m Kumar Bishojit Paul, the Founder and CEO of BIKIRAN. If you need further assistance, please leave a comment. I’m interested in helping you.

🏢 About Bikiran

Bikiran is a software development and cloud infrastructure company founded in 2012, headquartered in Khulna, Bangladesh. With 15,000+ clients and over a decade of experience, Bikiran builds and operates a suite of products spanning domain services, cloud hosting, app deployment, workflow automation, and developer tools.

1. Understanding the ESXi VM Disk Files

In your ESXi VM folder, you’ll typically see files such as:

• demo-vm_1.vmdk (small descriptor file)

• demo-vm_1-flat.vmdk (large disk data file)

For migration, you only need the matching descriptor and flat file for the active disk.

2. Preparing the Migration

Step 1: Copy VMDK Files to a Linux Machine

First, transfer the disk files from your ESXi server to a local Linux system using SCP/NFS:

scp root@esxi-host:/vmfs/volumes/.../demo-vm_1.vmdk /tmp/
scp root@esxi-host:/vmfs/volumes/.../demo-vm_1-flat.vmdk /tmp/

The descriptor (demo-vm_1.vmdk) must reference the demo-vm_1-flat.vmdk file and both should be in the same directory for conversion.

Step 2: Convert VMDK to QCOW2 Format

SolusVM2 (KVM) works best with QCOW2 disk images. Use qemu-img to convert:

sudo apt update
sudo apt install qemu-utils
cd /tmp
qemu-img convert -f vmdk -O qcow2 demo-vm_1.vmdk demo-vm_1.qcow2

The resulting demo-vm_1.qcow2 contains your VM’s disk, ready for import.

3. Importing to SolusVM2

Step 3: Upload QCOW2 Image to SolusVM2 Node

Transfer your QCOW2 disk to the KVM node’s image directory:

scp demo-vm_1.qcow2 root@solusvm-kvm-node:/var/lib/libvirt/images/

Step 4: Create the VM in SolusVM2

• Log in to the SolusVM2 admin panel.

• Create a new KVM VM, setting CPU, RAM, and Network as needed.

• For disk, select “use existing image” if available, or create a VM with a blank disk and replace that disk file with your demo-vm_1.qcow2 via SSH.

• Ensure the disk file ownership is correct (e.g., chown qemu:qemu demo-vm_1.qcow2).

4. Troubleshooting Dracut Initqueue Timeout (LVM Boot Issues)

The Problem

After migration, you may encounter errors like:

dracut-initqueue: timeout, still waiting for following initqueue hooks: /dev/mapper/demo-root /dev/demo-vg/swap

This means the initramfs (dracut) cannot find the root and swap LVM volumes.

Step 5: Recovery Workflow

A. Boot into Rescue Mode

• If you’re dropped into a dracut:/# shell, you can start recovery directly.

• Otherwise, boot from a rescue ISO (CentOS, AlmaLinux, Rocky, Fedora, etc.)

B. Check Disk Detection

lsblk
fdisk -l

If the disk isn’t detected, try changing the VM’s disk controller (Virtio, SATA, SCSI) in SolusVM2.

C. Scan and Activate LVM Volumes

vgscan
lvscan
vgchange -ay

If /dev/mapper/demo-root and /dev/demo-vg/swap appear, your volumes are present.

D. Inspect and Fix /etc/fstab and GRUB

Mount your root volume:

mount /dev/demo-vg/root /mnt
cat /mnt/etc/fstab

• Ensure device names or UUIDs match the actual LVM devices (blkid helps).

• Update /etc/fstab if needed.

E. Rebuild Initramfs

Chroot into your root volume and rebuild the initramfs for new hardware config:

mount --bind /dev /mnt/dev
mount --bind /proc /mnt/proc
mount --bind /sys /mnt/sys
chroot /mnt
dracut --force
exit
umount /mnt/{dev,proc,sys}
umount /mnt

F. Update GRUB Bootloader (Optional)

chroot /mnt
grub2-mkconfig -o /boot/grub2/grub.cfg
grub2-install /dev/vda  # or your disk device
exit

G. Reboot and Test

Reboot the VM. If boot fails, repeat the checks above.

5. Tips and Common Pitfalls

• Disk Not Detected? Change SolusVM2 disk bus to Virtio, SATA, or SCSI.

• LVM Names Changed? Check with vgs and lvs and update /etc/fstab.

• UUID Mismatch? Use blkid to verify and fix /etc/fstab.

• LVM Not Activating? Force scan or review /etc/lvm/lvm.conf.

6. Conclusion

Migrating a Linux VM from ESXi to SolusVM2 using QCOW2 is a reliable process if you prepare disk files properly and understand storage layers. The most common post-migration issue is dracut failing to find your LVM root volume—address this by scanning/activating LVM, rebuilding initramfs, and verifying disk controller compatibility.

CONTACT:

I’m Kumar Bishojit Paul, the Founder and CEO of BIKIRAN. If you need further assistance, please leave a comment. I’m interested in helping you.

Follow these steps for a seamless migration and fast recovery from boot issues!

🏢 About Bikiran

Bikiran is a software development and cloud infrastructure company founded in 2012, headquartered in Khulna, Bangladesh. With 15,000+ clients and over a decade of experience, Bikiran builds and operates a suite of products spanning domain services, cloud hosting, app deployment, workflow automation, and developer tools.

Questions, comments, or troubleshooting tips? Add them below!

Why Configure a Static IP and Custom Routes?

• Static IP: Ensures your system always has the same address, which is crucial for remote access, web hosting, and network services.

• Custom Routes: Control how traffic moves through your network, optimize connections, or access specific remote hosts.

Step 1: Identify Your Network Interface

The first step is to determine which network interface you want to configure. Interface names on Ubuntu can be eth0, ens3, enp0s3, etc.

ip link show

Look for an interface that is UP and connected. Example output:

2: ens3: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 ...

Here, ens3 is our interface.

Step 2: Prepare Your Static IP Details

Before configuring, gather the following information (using demo values):

• IP Address: 192.0.2.10

• Subnet Mask/CIDR: /24

• Gateway: 192.0.2.1

• DNS Server(s): 8.8.8.8 (Google Public DNS)

Step 3: Configure Netplan (Ubuntu 18.04+)

Ubuntu uses Netplan for network configuration. Netplan files are found in /etc/netplan/. List them:

ls /etc/netplan/

Open the appropriate file (e.g., 01-netcfg.yaml) for editing:

sudo nano /etc/netplan/01-netcfg.yaml

Add or update with your configuration (using demo IPs):

network:
  version: 2
  ethernets:
    ens3:
      dhcp4: no
      addresses:
        - 192.0.2.10/24
      gateway4: 192.0.2.1
      nameservers:
        addresses: [8.8.8.8]
      routes:
        - to: 192.0.2.1/32
          scope: link
          via: 0.0.0.0
          on-link: true
        - to: default
          via: 192.0.2.1
          on-link: true

Explanation:

• dhcp4: no: Disables DHCP, enables static IP.

• addresses: Sets the IP and subnet mask.

• gateway4: Sets the gateway for outbound traffic.

• nameservers: DNS servers for resolving domain names.

• routes:

  • to: Destination for the route (single IP or default).

  • scope: link means route is directly reachable on the local interface.

  • via: Next hop; 0.0.0.0 means direct, no gateway.

  • on-link: Tells the system this address is directly reachable.

  • default route: For all traffic not matched by other routes, use the specified gateway.

Step 4: Apply Your Configuration

Run the following to activate your changes:

sudo netplan apply

Step 5: Verify Your Network Configuration

Check your IP address:

ip a

Check your routing table:

ip route

Sample output:

192.0.2.1 dev ens3  scope link
default via 192.0.2.1 dev ens3

Check your DNS:

cat /etc/resolv.conf

Test connectivity:

ping -c 4 8.8.8.8
ping -c 4 example.com

Understanding Routes in Detail

What is a Route?

A route tells your system how to reach networks or hosts. The routing table contains rules that determine which interface and gateway traffic uses.

Key Route Fields

• scope: link: The destination is directly reachable on the local network (no gateway needed).

• to: The target IP or network (e.g., 192.0.2.1/32 for one host, or default for all traffic).

• via: The next hop (gateway) for reaching the destination. 0.0.0.0 means direct (no gateway).

• on-link: Marks the destination as directly reachable on the local segment.

Example 1: Link-Scoped Route

- to: 192.0.2.1/32
  scope: link
  via: 0.0.0.0
  on-link: true

• Packets destined for 192.0.2.1 are sent directly via ens3, with no gateway.

Example 2: Default Route

- to: default
  via: 192.0.2.1
  on-link: true

• All traffic not matching a more specific rule goes to the gateway 192.0.2.1.

Summary Table: Route Fields

Visual Example (Routing Table)

Imagine your routing table looks like this:

Destination        Gateway         Genmask         Flags Iface
192.0.2.1          0.0.0.0         255.255.255.255 UGH   ens3
0.0.0.0            192.0.2.1       0.0.0.0         UG    ens3

• First row: Direct route to 192.0.2.1 via ens3 (no gateway).

• Second row: Default route—send everything else via 192.0.2.1.

Troubleshooting

• Network unreachable: Double-check IP, gateway, and interface name.

• YAML errors: Make sure you use spaces (not tabs) and correct indentation in Netplan files.

• DNS not working: Some systems may overwrite /etc/resolv.conf. Use Netplan to set DNS or configure systemd-resolved.

• Connectivity issues: Use ip a, ip route, and ping to diagnose.

Advanced: Temporary Network Changes (No Reboot Needed)

If you want to test settings without editing Netplan, use these commands (using demo IPs):

sudo ip addr flush dev ens3
sudo ip addr add 192.0.2.10/24 dev ens3
sudo ip link set ens3 up
sudo ip route add 192.0.2.1 dev ens3
sudo ip route add default via 192.0.2.1
echo "nameserver 8.8.8.8" | sudo tee /etc/resolv.conf

Note: These changes are lost after reboot.

Conclusion

Configuring a static IP address and custom routes on Ubuntu is straightforward once you understand the concepts and configuration syntax. Whether you’re running a server, a cloud VM, or a desktop, these steps ensure your system is reliably reachable and communicates efficiently on your network.

CONTACT:

I’m Kumar Bishojit Paul, the Founder and CEO of BIKIRAN. If you need further assistance, please leave a comment. I’m interested in helping you.

Key Takeaways:

• Know your network interface name.

• Use Netplan for permanent configuration.

• Understand how routes work—especially link scope and default routes.

• Test and verify your setup for reliability.

Have questions or want to learn more about advanced routing? Comment below or explore Ubuntu’s official networking documentation!

🏢 About Bikiran

Bikiran is a software development and cloud infrastructure company founded in 2012, headquartered in Khulna, Bangladesh. With 15,000+ clients and over a decade of experience, Bikiran builds and operates a suite of products spanning domain services, cloud hosting, app deployment, workflow automation, and developer tools.

1. Identify Your Network Interface

Check available network interfaces and note the one you want to configure (e.g., ens3).

ip link show

2. Flush Existing IP Addresses

Remove all current IP addresses from your interface to avoid conflicts.

sudo ip addr flush dev ens3

Replace ens3 with your actual interface name.

3. Assign a New IP Address

Set the desired IP address and subnet mask.

sudo ip addr add 51.1.1.51/24 dev ens3

• 51.1.1.51 is the new IP.

• /24 is the subnet mask (255.255.255.0).

4. Bring the Interface Up

Activate the interface if it is down.

sudo ip link set ens3 up

5. Set Up Routing

a. Add a Static Route (Optional)

If you need to reach a specific host directly:

sudo ip route add 15.2.2.15 dev ens3

b. Set the Default Gateway

Direct all traffic through the gateway:

sudo ip route add default via 15.2.2.15

6. Configure DNS

Set a DNS server to resolve domain names.

echo "nameserver 8.8.8.8" | sudo tee /etc/resolv.conf

This replaces your /etc/resolv.conf with Google’s DNS.
Note: Changes to /etc/resolv.conf are also temporary and may be overwritten by network managers.

7. Automatic Setup Script

You can use the following shell script to automate this temporary network setup.
This script will prompt you for the required details and apply the configuration.

#!/bin/bash

# Temporary Linux Network Configuration (Interactive Script)

echo "=== Temporary Network Configuration ==="

# Prompt for network interface
read -p "Enter the network interface name (e.g., ens3): " IFACE

# Prompt for new IP address (with CIDR)
read -p "Enter the new IP address with CIDR (e.g., 192.168.1.100/24): " IPADDR

# Prompt for Gateway
read -p "Enter the gateway IP address (e.g., 192.168.1.1): " GATEWAY

# Prompt for DNS
read -p "Enter the DNS server IP (e.g., 8.8.8.8): " DNS

echo ""
echo "Applying network changes..."

# Flush existing IP addresses
sudo ip addr flush dev "$IFACE"

# Assign new IP address
sudo ip addr add "\(IPADDR" dev "\)IFACE"

# Bring the interface up
sudo ip link set "$IFACE" up

# Add default gateway
sudo ip route add default via "$GATEWAY"

# Set DNS server
echo "nameserver $DNS" | sudo tee /etc/resolv.conf

echo ""
echo "Network configuration applied (temporarily, until reboot)."
echo "Current network status:"
ip addr show "$IFACE"
ip route

echo ""
echo "Test connectivity (ping DNS server):"
ping -c 4 "$DNS"

echo ""
echo "Done."

Usage:

1. Save as network_setup_prompt.sh.

2. Make executable: chmod +x network_setup_prompt.sh

3. Run: ./network_setup_prompt.sh

4. Follow prompts to input interface, IP address, gateway, and DNS.

Note:
This configuration is temporary and will be lost after a reboot. For permanent changes, edit your network configuration files.

8. Verify Configuration

a. Check IP Address

ip a

b. Check Routing Table

ip route

c. Test Connectivity

• Ping gateway or external IP:

  ping -c 4 8.8.8.8
  

• Test DNS:

  ping -c 4 google.com
  

9. (Optional) Install Open vSwitch

If you need Open vSwitch for virtual networking:

sudo apt update
sudo apt install openvswitch-switch

10. Notes

• Temporary: These changes will be lost after a reboot. For permanent changes, edit your network configuration files (e.g., /etc/network/interfaces, Netplan, or NetworkManager settings).

• Permissions: All commands require root privileges (sudo).

• Interface Name: Replace ens3 with your actual interface name.

11. Troubleshooting

• If network is not working, check:

  • IP address assignment: ip a

  • Routing table: ip route

  • DNS settings: cat /etc/resolv.conf

  • Interface status: ip link show ens3

• Re-run commands if you made a mistake or want to reset.

CONTACT:

I’m Kumar Bishojit Paul, the Founder and CEO of BIKIRAN. If you need further assistance, please leave a comment. I’m interested in helping you.

🏢 About Bikiran

Bikiran is a software development and cloud infrastructure company founded in 2012, headquartered in Khulna, Bangladesh. With 15,000+ clients and over a decade of experience, Bikiran builds and operates a suite of products spanning domain services, cloud hosting, app deployment, workflow automation, and developer tools.

What is hostnamectl?

hostnamectl is a command-line utility introduced with systemd that allows users to query and change the system hostname and related metadata. It provides a unified interface for managing not just the hostname but also additional system descriptors like chassis type, deployment environment, and location.

Key Features:

• Query current hostname and system metadata

• Change static, transient, or pretty hostnames

• Set additional system metadata

• Standardized interface on all systemd-based distributions

Hostname Types Explained

Linux systems now recognize several types of hostnames:

1. Static Hostname

   • Stored in /etc/hostname

   • Persistent across reboots

2. Transient Hostname

   • Set by the kernel, DHCP, or manually for the current session

   • Not persistent after reboot

3. Pretty Hostname

   • A user-friendly version (can include spaces and special characters)

   • Used for display in GUIs

How to Use hostnamectl

1. Viewing Hostname and System Metadata

Simply run:

hostnamectl

This displays information like:

• Static, transient, and pretty hostnames

• Icon name

• Chassis type (desktop, server, vm, etc.)

• Deployment environment (production, testing, etc.)

• Location

• Machine and boot IDs

• Operating system and kernel

Sample Output:

   Static hostname: myserver
         Icon name: computer-server
           Chassis: server
        Machine ID: 1234567890abcdef
           Boot ID: abcdef1234567890
  Operating System: Ubuntu 22.04 LTS
            Kernel: Linux 5.15.0-72-generic
      Architecture: x86-64

2. Setting the Hostname

To set the static hostname:

sudo hostnamectl set-hostname new-hostname

Set a pretty hostname:

sudo hostnamectl set-hostname "My Workstation" --pretty

Set a transient hostname:

sudo hostnamectl set-hostname temp-host --transient

3. Setting System Metadata

You can also set metadata for better system identification:

sudo hostnamectl set-chassis laptop
sudo hostnamectl set-deployment production
sudo hostnamectl set-location "Rack 2, DC1"

Advanced Usage

Scripting with hostnamectl

Automate hostname and metadata setup in deployment scripts:

#!/bin/bash
sudo hostnamectl set-hostname "$1"
sudo hostnamectl set-chassis "$2"
sudo hostnamectl set-location "$3"

Run: ./sethost.sh myhost server "Room 27"

Integration with Networking

Transient hostnames may be set by DHCP servers—ideal for cloud or dynamic environments. If your hostname keeps changing, review your DHCP client configuration.

Troubleshooting

• Hostname not changing? Use sudo and verify that your distribution uses systemd.

• DHCP resets hostname? Adjust DHCP client settings to prevent overwriting.

• Change not recognized? Try logging out or rebooting if some applications don’t pick up the new hostname immediately.

Why Use hostnamectl?

• Consistency: Works across all systemd-based distributions.

• Safety: Avoids manual file edits and possible misconfigurations.

• Integration: Metadata is available to other tools and GUIs.

• Flexibility: Set hostnames for different purposes and environments.

Resources

• hostnamectl man page

• systemd-hostnamed documentation

Conclusion

Whether you’re managing a single desktop or thousands of servers, hostnamectl streamlines hostname management and adds a layer of metadata that’s invaluable for automation, monitoring, and inventory. Give it a try—and modernize your Linux workflow!

CONTACT:

I’m Kumar Bishojit Paul, the Founder and CEO of BIKIRAN. If you need further assistance, please leave a comment. I’m interested in helping you.

🏢 About Bikiran

Bikiran is a software development and cloud infrastructure company founded in 2012, headquartered in Khulna, Bangladesh. With 15,000+ clients and over a decade of experience, Bikiran builds and operates a suite of products spanning domain services, cloud hosting, app deployment, workflow automation, and developer tools.

This guide provides a safe, step-by-step process to convert a Linux VM disk from UEFI boot to BIOS, preserving your data and minimizing downtime.

Why Does This Happen?

• UEFI and BIOS are different firmware types.
  A VM created on VMware may use UEFI, but KVM (and SolusVM) often expect BIOS (SeaBIOS).

• OS bootloaders are installed differently for UEFI and BIOS.
  UEFI boots from an EFI System Partition (/boot/efi), while BIOS boots from the MBR using GRUB or similar bootloaders.

• A disk converted from VMDK to QCOW2 may be unbootable if the boot mode/fimware doesn’t match.

Identifying Your Boot Mode

On the Original VMware Host

1. Check VM Settings in vSphere/ESXi:

   • Edit the VM.

   • Look for "Boot Options" or "Firmware."

   • If set to "EFI" or "UEFI," your VM uses UEFI. If "BIOS," it uses legacy BIOS.

2. Check the Filesystem:

   • Mount the disk image (VMDK/QCOW2) on another Linux machine or VM.

   • Look for /boot/efi. If this folder exists and is populated, your VM likely used UEFI.

   guestmount -a server-48.bikiran.net-flat.qcow2 -i --ro /mnt
   ls /mnt/boot/efi
   

   If you see files here, it's UEFI.

Steps to Convert UEFI to BIOS Boot

Warning:

• Always back up your VM's disk image before proceeding.

• These steps assume a Linux guest. For Windows, the process is significantly different.

1. Prepare a Rescue Environment

• Boot the VM using a Linux live CD/ISO (e.g., Ubuntu Live).

• Attach the converted QCOW2 disk if it isn't already.

2. Use an Automated Script

To simplify and reduce risk, use the following bash script. This script will:

• Detect your root partition.

• Mount it and chroot into your system.

• Install GRUB for legacy BIOS boot.

• Remove /boot/efi mount from /etc/fstab.

• Clean up and unmount everything.

Save this as convert-uefi-to-seabios.sh:

#!/bin/bash
# convert-uefi-to-seabios.sh: Convert a Linux VM from UEFI boot to legacy BIOS boot (SeaBIOS).
# Usage: sudo bash convert-uefi-to-seabios.sh /dev/vda

set -e

DISK="$1"

if [[ -z "$DISK" ]]; then
  echo "Usage: $0 /dev/vdX (replace with your disk device, e.g., /dev/vda)"
  exit 1
fi

# Find Linux root partition (assume it's the largest Linux partition)
ROOT_PART=\((lsblk -lnpo NAME,SIZE,TYPE,FSTYPE | grep -E "ext4|xfs|btrfs" | sort -rk2 | head -n1 | awk '{print \)1}')
if [[ -z "$ROOT_PART" ]]; then
  echo "Could not detect Linux root partition. Please specify manually."
  exit 1
fi

echo "Mounting root partition: $ROOT_PART"
mkdir -p /mnt/root
mount "$ROOT_PART" /mnt/root

if [ -d /mnt/root/boot/efi ]; then
  echo "/boot/efi detected. Proceeding with UEFI to BIOS conversion."
else
  echo "No /boot/efi found. The system may already use BIOS boot."
  umount /mnt/root
  exit 0
fi

echo "Binding system filesystems..."
mount --bind /dev /mnt/root/dev
mount --bind /proc /mnt/root/proc
mount --bind /sys /mnt/root/sys

echo "Chrooting into system..."
chroot /mnt/root /bin/bash <<'EOT'
set -e
echo "Installing GRUB for BIOS..."
grub-install --target=i386-pc --recheck /dev/vda
echo "Updating GRUB config..."
update-grub || grub2-mkconfig -o /boot/grub2/grub.cfg
echo "Removing /boot/efi entry from /etc/fstab..."
sed -i '/\/boot\/efi/d' /etc/fstab
echo "UEFI to BIOS conversion completed inside chroot."
EOT

echo "Cleaning up /boot/efi..."
rm -rf /mnt/root/boot/efi

echo "Unmounting filesystems..."
umount /mnt/root/sys
umount /mnt/root/proc
umount /mnt/root/dev
umount /mnt/root

echo "Done. Please detach the ISO and try to boot with SeaBIOS (legacy boot)."

3. Run the Script

1. Make it executable:

   chmod +x convert-uefi-to-seabios.sh
   

2. Execute (replace /dev/vda as needed):

   sudo ./convert-uefi-to-seabios.sh /dev/vda
   

4. Switch the VM Firmware to SeaBIOS

• In SolusVM/KVM, ensure the VM firmware is set to BIOS/SeaBIOS (not UEFI/OVMF).

5. Reboot and Test

• Reboot the VM.

• The VM should boot from the hard disk using BIOS/SeaBIOS.

Troubleshooting

• Disk Uses GPT Instead of MBR:
  BIOS boot with GPT is possible (with a BIOS boot partition), but many tools expect MBR. Seek advanced guidance if you’re using GPT.

• OS Is Windows:
  This script is for Linux guests. For Windows, the process is very different and more complex.

• No OS Found:
  Double-check that GRUB is installed to the correct disk and that the root partition is correct.

• Still Not Booting?
  Attach the disk to another VM, check /boot/grub contents, or review /var/log/libvirt/qemu/<vmname>.log for errors.

Conclusion

Migrating VMs between platforms is never truly "plug and play," especially when firmware and boot mechanisms differ. This guide and script should make converting your Linux VM from UEFI to BIOS for KVM much easier and safer. Always back up your data, and proceed with caution!

CONTACT:

I’m Kumar Bishojit Paul, the Founder and CEO of BIKIRAN. If you need further assistance, please leave a comment. I’m interested in helping you.

Have questions or need a version for GPT partitioned disks or Windows? Leave a comment!

🏢 About Bikiran

Bikiran is a software development and cloud infrastructure company founded in 2012, headquartered in Khulna, Bangladesh. With 15,000+ clients and over a decade of experience, Bikiran builds and operates a suite of products spanning domain services, cloud hosting, app deployment, workflow automation, and developer tools.

What is qemu-img convert?

qemu-img convert is part of the qemu-img suite. Its main function is to convert one disk image format to another, but it can also compress, sparsify, and resize images in the process.

Common formats supported:

• qcow2 (QEMU/KVM native)

• raw

• vmdk (VMware)

• vdi (VirtualBox)

• vhd/vhdx (Microsoft Hyper-V)

• parallels (Parallels Desktop)

Basic Syntax

qemu-img convert [options] -O <output_format> <input_image> <output_image>

Examples:

• Convert a raw image to qcow2:

  qemu-img convert -O qcow2 disk.raw disk.qcow2
  

• Convert a vmdk (VMware) to qcow2:

  qemu-img convert -O qcow2 disk.vmdk disk.qcow2
  

Common Use Cases

1. Convert Between Formats

• VMware VMDK to QCOW2 (KVM):

  qemu-img convert -O qcow2 source.vmdk dest.qcow2
  

• VirtualBox VDI to RAW:

  qemu-img convert -O raw source.vdi dest.raw
  

• RAW to VHDX (Hyper-V):

  qemu-img convert -O vhdx source.raw dest.vhdx
  

2. Compress Disk Images

Use the -c flag to compress supported formats (like qcow2):

qemu-img convert -c -O qcow2 source.qcow2 dest.qcow2

3. Create a Sparse Image

If your input image is thick provisioned (all blocks allocated), you can make the output sparse (only actual data blocks allocated):

qemu-img convert -O qcow2 thick.qcow2 sparse.qcow2

4. Resize During Conversion

Use the -S (sparsify) option to ignore data blocks with only zeros, making the target image smaller:

qemu-img convert -O qcow2 -S 0 source.qcow2 dest.qcow2

5. Convert and Encrypt Disk Images

You can encrypt the output qcow2 image:

qemu-img convert -O qcow2 --object secret,id=sec0,data=YOURPASSWORD \
  -o encrypt.format=luks,encrypt.key-secret=sec0 source.raw dest.qcow2

Replace YOURPASSWORD with a strong password or use secret files as recommended by QEMU docs.

Advanced Examples

Convert and Change Size

You can resize images after conversion with qemu-img resize:

qemu-img convert -O qcow2 source.raw dest.qcow2
qemu-img resize dest.qcow2 100G

Convert Multiple Images (Snapshots)

For images with snapshots or backing files, use --backing-chain to include the entire chain:

qemu-img convert -O qcow2 --backing-chain snap.qcow2 full.qcow2

Full List of Key Options

• -O <fmt>: Output format (qcow2, raw, vmdk, vdi, vhdx, etc.)

• -c: Compress the output image (for supported formats)

• -p: Show progress bar

• -S <size>: Sparsify zeros (ignore zeroed blocks above this size)

• -f <fmt>: Input format (auto-detected if omitted)

• --backing-chain: Convert the entire snapshot/backing chain

• -o <options>: Format-specific options (e.g., cluster_size for qcow2, preallocation, encryption)

• -n: Do not create the output file, just test conversion

Tips and Best Practices

• Always backup your disk images before converting or overwriting!

• For best compaction, zero-fill free space inside the guest OS before converting (e.g., with dd or SDelete).

• After conversion, use qemu-img info <image> to inspect the result.

• When moving VMs between hypervisors, check for driver and hardware compatibility after conversion.

Troubleshooting

• Error: “format not supported”
  Make sure you have the necessary QEMU modules/libraries for your source/target formats.

• Image won’t boot after conversion
  Check that your VM configuration matches the new format (bus type, drivers, etc.)

References

• QEMU Documentation: qemu-img

• libvirt Disk Images

Conclusion

qemu-img convert is your Swiss Army knife for virtual disk image management—whether you’re migrating between platforms, reclaiming space, or compressing images for backups. Experiment in a safe environment and take regular backups to make the most of this essential tool!

CONTACT:

I’m Kumar Bishojit Paul, the Founder and CEO of BIKIRAN. If you need further assistance, please leave a comment. I’m interested in helping you.

🏢 About Bikiran

Bikiran is a software development and cloud infrastructure company founded in 2012, headquartered in Khulna, Bangladesh. With 15,000+ clients and over a decade of experience, Bikiran builds and operates a suite of products spanning domain services, cloud hosting, app deployment, workflow automation, and developer tools.

This blog walks you through using a safe, interactive Bash script (auto_disk_resize_fixed.sh) that automates these steps for Ubuntu/Debian systems. You’ll learn how it works, how to run it, and what’s happening behind the scenes.

Why Isn't the New Space Available Right Away?

When you expand the disk in your VPS control panel, the underlying virtual disk grows instantly. However:

• Your existing partition (e.g., /dev/sda3) doesn’t automatically expand to fill the new space.

• LVM’s physical volume (PV), volume group (VG), and logical volume (LV) are all still the same size as before.

• Your filesystem (ext4, xfs, etc.) can only use the space allocated to the LV.

Result: Even though your disk is bigger, df -h still shows the old size for your root filesystem.

What Does the Script Do?

The script auto_disk_resize_fixed.sh guides you through the safest way to expand your root partition and filesystem:

1. Detects your LVM setup, disk devices, partition numbers, and logical volumes.

2. Prompts you for confirmation before making any changes.

3. Grows the partition using growpart to fill the new disk.

4. Resizes the LVM PV so LVM can use the new space.

5. Extends the LV (root filesystem) to use all available space.

6. Expands the filesystem (ext4 or xfs) to match the new LV size.

7. Shows you the results with a final df -h.

Step-by-Step: How to Use the Script

1. Prepare the Script

Copy the following script and save it as auto_disk_resize_fixed.sh:

#!/bin/bash
set -euo pipefail

# ==============================================================================
# SAFE AUTO DISK RESIZE SCRIPT (FIXED)
# This script safely expands an LVM root filesystem after resizing a VM disk.
# - Automatically detects the correct disk, partition, and LVM layout.
# - Uses growpart, pvresize, lvextend, and resize2fs/xfs_growfs as appropriate.
# - Prompts user for confirmation before making changes.
# - Intended for Ubuntu/Debian systems using LVM.
# ==============================================================================

echo "==== SAFE AUTO DISK RESIZE SCRIPT (FIXED) ===="

# Step 1: Show current block devices so the user can visually confirm layout
echo "[1] Block devices:"
lsblk
echo

# Step 2: Detect the LVM physical volume (PV) partition (e.g., /dev/sda3)
# This is the partition we want to resize to fill the new disk size
PV_PATH=\((pvs --noheadings -o pv_name | awk '{print \)1}' | head -1)
if [[ -z "$PV_PATH" ]]; then
  echo "ERROR: Could not detect LVM physical volume. Exiting."
  exit 1
fi

# Step 3: Detect the underlying disk device (e.g., /dev/sda) for the PV
DISK_DEV=\((lsblk -no PKNAME "\)PV_PATH" | head -1)
if [[ -z "$DISK_DEV" ]]; then
  echo "ERROR: Could not detect underlying disk for $PV_PATH. Exiting."
  exit 1
fi
DISK="/dev/$DISK_DEV"

# Step 4: Extract the partition number (e.g., 3 for /dev/sda3)
PART_NUM=\((echo "\)PV_PATH" | grep -o '[0-9]*$')
if [[ -z "$PART_NUM" ]]; then
  echo "ERROR: Could not determine partition number from $PV_PATH. Exiting."
  exit 1
fi

# Show current partition table for the detected disk
echo "[2] Partition table for $DISK:"
sudo fdisk -l "$DISK"
echo

echo "Detected:"
echo "  LVM PV      : $PV_PATH"
echo "  Disk device : $DISK"
echo "  Part number : $PART_NUM"
echo

# Step 5: Prompt user to confirm values before making any changes
read -rp "Are these values correct and do you want to proceed with resizing? (yes/no): " confirm
if [[ "$confirm" != "yes" ]]; then
  echo "Aborting for safety."
  exit 1
fi

# Step 6: Install growpart if not already available
echo "[3] Installing growpart if needed..."
if ! command -v growpart &>/dev/null; then
  sudo apt-get update
  sudo apt-get install -y cloud-guest-utils
fi

# Step 7: Grow the LVM partition to occupy the new disk space
echo "[4] Growing partition \(PART_NUM on \)DISK using growpart..."
sudo growpart "\(DISK" "\)PART_NUM"

# Step 8: Resize the LVM physical volume to utilize the expanded partition
echo "[5] Resizing LVM physical volume $PV_PATH..."
sudo pvresize "$PV_PATH"

# Step 9: Find the logical volume (LV) path for the root filesystem (e.g., /dev/ubuntu-vg/ubuntu-lv)
ROOT_LV_PATH=$(findmnt -n -o SOURCE /)
VG=\((lvs --noheadings -o vg_name "\)ROOT_LV_PATH" | awk '{print $1}' | head -1)
LV=\((lvs --noheadings -o lv_name "\)ROOT_LV_PATH" | awk '{print $1}' | head -1)
LV_PATH="/dev/\(VG/\)LV"

echo
echo "Root LV Path  : $LV_PATH"
read -rp "Ready to extend LV ($LV_PATH) and resize filesystem. Proceed? (yes/no): " confirm2
if [[ "$confirm2" != "yes" ]]; then
  echo "Aborting for safety."
  exit 1
fi

# Step 10: Extend the logical volume to use all newly available space
echo "[6] Extending logical volume to use all free space..."
sudo lvextend -l +100%FREE "$LV_PATH"

# Step 11: Resize the filesystem on the logical volume to match the new size
echo "[7] Resizing filesystem..."
FS_TYPE=\((df -T / | tail -1 | awk '{print \)2}')
if [[ "$FS_TYPE" == "xfs" ]]; then
  sudo xfs_growfs /
else
  sudo resize2fs "$LV_PATH"
fi

# Step 12: Show the new disk usage to confirm success
echo
echo "[8] Disk usage after resize:"
df -h

echo "==== Done. Your disk should now show the full size. ===="

2. Make the Script Executable

chmod +x auto_disk_resize_fixed.sh

3. Run the Script as Root

sudo ./auto_disk_resize_fixed.sh

4. Follow the Prompts

• The script will show you the detected disk, LVM, and partition details.

• Carefully review these before answering "yes" to proceed.

• The script will pause before each major change for your confirmation.

What’s Happening Behind the Scenes?

• growpart expands the partition table entry for your LVM partition to fill the whole virtual disk.

• pvresize tells LVM that new space is available in the physical volume.

• lvextend grows the logical volume (LV) so your root filesystem can use the new space.

• resize2fs or xfs_growfs grows the filesystem itself to match the new LV size.

Safety Tips

• Always backup any critical data before resizing disks or filesystems.

• This script is interactive. If anything looks wrong in the detected devices, abort and double-check your server’s layout!

• Only run this if your root filesystem is on LVM (most Ubuntu "Guided - use entire disk and set up LVM" installs use this layout).

Troubleshooting

• If the script aborts with an error, check that your system uses LVM and that you’ve actually expanded the disk in your VPS control panel.

• If your system uses standard partitions (not LVM), this script will not work for you.

• If you see any error, copy the error message and seek advice before retrying.

Conclusion

Expanding a disk on a virtual server isn’t finished after you click “resize” in your cloud control panel. Use this script to safely automate the process for LVM-based Ubuntu systems, with full visibility and control at each step.

CONTACT:

I’m Kumar Bishojit Paul, the Founder and CEO of BIKIRAN. If you need further assistance, please leave a comment. I’m interested in helping you.

Have questions or feedback? Leave a comment below!

🏢 About Bikiran

Bikiran is a software development and cloud infrastructure company founded in 2012, headquartered in Khulna, Bangladesh. With 15,000+ clients and over a decade of experience, Bikiran builds and operates a suite of products spanning domain services, cloud hosting, app deployment, workflow automation, and developer tools.

Deploying MySQL on a remote server unlocks scalable application architecture but introduces security and configuration challenges. This guide walks through:

• Secure MySQL installation

• Remote access configuration

• Database migration strategies

• PHP connectivity

• Production hardening

• Performance tuning

Tested on Ubuntu 22.04 LTS | MySQL 8.0 | PHP 8.1

🔑 Prerequisites

1. Server Specifications:

   • Ubuntu 22.04 LTS (2+ vCPU, 4GB RAM recommended)

   • Public IP address (139.1.1.101 in this example)

2. Local Environment:

   • MySQL Workbench or mysqldump

   • SSH client (OpenSSH)

3. Security Essentials:

   • Firewall (UFW) enabled

   • SSH key authentication

🚀 Step-by-Step Implementation

🔐 1. Secure Server Initialization

# SSH with key authentication (recommended)
ssh -i ~/.ssh/your_key.pem karimtrd@139.1.1.101

# Create sudo user (if not exists)
sudo adduser deploy --gecos "" && sudo usermod -aG sudo deploy

Security Tip: Disable root SSH in /etc/ssh/sshd_config

🛠️ 2. MySQL Installation & Hardening

Install with TLS Support:

sudo apt update && sudo apt install mysql-server -y
sudo systemctl enable --now mysql

Configure Security:

sudo mysql_secure_installation

Follow these choices:

1. VALIDATE PASSWORD COMPONENT → Strong

2. Root password: Hello@Unlock!24Mysql

3. Remove anonymous users? → Yes

4. Disallow root login remotely? → Yes

5. Remove test database? → Yes

6. Reload privileges? → Yes

Verify Installation:

sudo mysql -u root -p
SHOW VARIABLES LIKE '%tls%';  # Confirm TLS active

🌐 3. Remote Access Configuration

Update MySQL Config:

sudo nano /etc/mysql/mysql.conf.d/mysqld.cnf

[mysqld]
bind-address = 0.0.0.0
# Enable binary logging for point-in-time recovery
log-bin = /var/log/mysql/mysql-bin.log
server-id = 1

Firewall Rules:

sudo ufw allow proto tcp from 192.168.1.0/24 to any port 3306  # Limit to your network
sudo ufw limit 22/tcp  # Protect SSH from brute-force
sudo ufw enable

Restart Service:

sudo systemctl restart mysql

👤 4. Database User & Privileges

CREATE DATABASE postech22_karimtraders
  CHARACTER SET utf8mb4
  COLLATE utf8mb4_unicode_ci;

CREATE USER 'vm_karimtraders'@'192.168.1.%' 
  IDENTIFIED WITH mysql_native_password BY 'Unlock!24Mysql@Do'
  REQUIRE SSL;  # Enforce TLS

GRANT SELECT, INSERT, UPDATE, DELETE, EXECUTE 
  ON postech22_karimtraders.* 
  TO 'vm_karimtraders'@'192.168.1.%';

USE postech22_karimtraders;

FLUSH PRIVILEGES;

Note: Avoid GRANT ALL and '%' wildcards in production

🚚 Database Migration Strategies

# Local export with compression
mysqldump -u root -p --single-transaction --routines \
  --triggers postech22_karimtraders | gzip > db_$(date +%F).sql.gz

# Secure transfer
scp -i ~/.ssh/key.pem db_2023-10-05.sql.gz karimtrd@139.1.1.101:~

# Remote import
gunzip < db_2023-10-05.sql.gz | mysql -u vm_karimtraders -p postech22_karimtraders

Method 2: MySQL Replication (Large Databases)

1. Configure master-slave replication

2. Promote the slave to primary after cutover

3. Update application connection strings

🔌 PHP Connectivity & Best Practices

PDO Connection with Error Handling:

<?php
$servername = "139.1.1.101";
$username = "vm_karimtraders";
$password = "Unlock!24Mysql@Do";
$dbname = "postech22_karimtraders";
$ssl = [
    PDO::MYSQL_ATTR_SSL_CA => '/etc/ssl/certs/ca-certificates.crt',
    PDO::MYSQL_ATTR_SSL_VERIFY_SERVER_CERT => true
];

try {
    $conn = new PDO(
        "mysql:host=\(servername;dbname=\)dbname;charset=utf8mb4",
        $username,
        $password,
        [
            PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
            PDO::ATTR_EMULATE_PREPARES => false,
            PDO::ATTR_PERSISTENT => true
        ] + $ssl
    );
    
    echo "Connected successfully with TLS encryption";
} catch (PDOException $e) {
    error_log("Connection failed: " . $e->getMessage());
    http_response_code(503);
    exit("Database maintenance in progress");
}
?>

Key Features:

• TLS encryption enforcement

• Prepared statements

• Persistent connections

• Graceful error handling

🔥 Production Hardening Checklist

1. Encryption:

   ALTER DATABASE postech22_karimtraders ENCRYPTION = 'Y';  # InnoDB tablespace encryption
   

2. Auditing:

   sudo apt install mysql-audit-plugin
   

3. Backup Automation:

   # Daily compressed backups with retention
   0 2 * * * /usr/bin/mysqldump -u bkpuser -p[Password] --single-transaction \
     --routines postech22_karimtraders | gzip > /backups/db_$(date +\%F).sql.gz \
     && find /backups -type f -mtime +30 -delete
   

4. Monitoring:

   • Enable Performance Schema: SET GLOBAL performance_schema=ON;

   • Install Percona Monitoring Plugins

⚡ Performance Tuning

my.cnf Optimizations:

[mysqld]
innodb_buffer_pool_size = 2G  # 70-80% of RAM
innodb_log_file_size = 256M
max_connections = 200
thread_cache_size = 50
query_cache_type = 0  # Disable on MySQL 8+

Connection Pooling in PHP:

$conn->setAttribute(PDO::ATTR_PERSISTENT, true);  # Reuse connections

Index Optimization:

EXPLAIN SELECT * FROM orders WHERE status = 'processing';
CREATE INDEX idx_orders_status ON orders(status);

🚨 Troubleshooting Guide

✅ Deployment Validation Checklist

1. Test local → remote connection: mysql -h 139.1.1.101 -u vm_karimtraders -p

2. Verify TLS: \s in MySQL client shows "SSL: Cipher in use"

3. Load test with sysbench

4. Validate backups: Restore to test instance

5. Test failover procedure (if replicated)

🌈 Conclusion

You've now deployed a production-grade MySQL server with:

• Encrypted network connections

• Least-privilege access control

• Automated backups

• Performance monitoring

• PHP connectivity best practices

Next Steps:

1. Implement read replicas for high-traffic apps

2. Set up automated failover with ProxySQL

3. Enable slow query logging for optimization

CONTACT:

I’m Kumar Bishojit Paul, the Founder and CEO of BIKIRAN. If you need further assistance, please leave a comment. I’m interested in helping you.

✨ Pro Tip: Use infrastructure-as-code tools like Ansible to automate this setup!

Enjoyed this guide?
✅ Follow me for more DevOps tutorials
🔁 Share with your engineering team
💬 Comment your deployment challenges!

🏢 About Bikiran

Bikiran is a software development and cloud infrastructure company founded in 2012, headquartered in Khulna, Bangladesh. With 15,000+ clients and over a decade of experience, Bikiran builds and operates a suite of products spanning domain services, cloud hosting, app deployment, workflow automation, and developer tools.

STEP-1: Configure Local Package Source

Add to your .csproj file:

<Project Sdk="Microsoft.NET.Sdk.Web">
    <PropertyGroup>
        <TargetFramework>net9.0</TargetFramework>
        <!-- Add local package source -->
        <RestoreAdditionalProjectSources>
            $(RestoreAdditionalProjectSources);
            D:\P_Bikiran\Bikiran.Validation\bin\Release\
        </RestoreAdditionalProjectSources>
    </PropertyGroup>

    <ItemGroup>
        <PackageReference Include="Bikiran.Validation" Version="1.0.7" />
    </ItemGroup>
</Project>

2. Package Development Workflow

1. Build your package

   Ensure your package project is built in the Release configuration

   dotnet build -c Release
   

2. Generate a .nupkg file

   dotnet pack --configuration Release
   

3. Verify package structure

   Confirm the .nupkg file exists in your output directory:

   D:\P_Bikiran\Bikiran.Validation\bin\Release\Bikiran.Validation.1.0.7.nupkg
   

3. Consumption in Live Projects

using Bikiran.Validation; // Your local package
using Bikiran.Utils.ApiResp;

public class DomainCnsAddProperty
{
    public string Cns { get; set; } = "";
    public List<string> Ips { get; set; } = [];

    public ApiResponse Validate()
    {
        var validationResult = ValidateBasic.ValidateAll([
            ValDomain.IsValidDomainFormat(Cns, "Child Name Server"),
            ValIP.IsValidIpFormatAll(Ips, "IP Addresses"),
        ]);

        return new ApiResponse {
            Error = validationResult.Error,
            Message = validationResult.Message,
            ReferenceName = GetReferenceName(validationResult.ErrorIndex)
        };
    }

    private string GetReferenceName(List<string> names, int? errorIndex)
        => errorIndex.HasValue ? names[errorIndex.Value] : "Validation";
}

Best Practices

1. Version Management

   • Increment versions systematically (SemVer recommended)

   • Use wildcards for development versions: 1.0.*

2. Dependency Isolation

   <PackageReference Include="Bikiran.Validation" Version="1.0.7">
     <PrivateAssets>all</PrivateAssets>
   </PackageReference>
   

3. CI/CD Integration

   Consider adding a local package directory in your build pipeline:

   <RestoreAdditionalProjectSources>
     $(RestoreAdditionalProjectSources);
     $(Build.SourcesDirectory)\artifacts
   </RestoreAdditionalProjectSources>
   

Troubleshooting Common Issues

1. Package Not Found

   • Verify the .nupkg file exists at the specified path

   • Check package version consistency

   • Clear NuGet caches: dotnet nuget locals all --clear

2. Version Conflicts

   Use exact versions during development:

   <PackageReference Include="Bikiran.Validation" Version="[1.0.7]" />
   

3. IntelliSense Issues

   • Restart IDE after package updates

   • Run dotnet restore manually

CONTACT:

I’m Kumar Bishojit Paul, the Founder and CEO of BIKIRAN. If you need further assistance, please leave a comment. I’m interested in helping you.

🏢 About Bikiran

Bikiran is a software development and cloud infrastructure company founded in 2012, headquartered in Khulna, Bangladesh. With 15,000+ clients and over a decade of experience, Bikiran builds and operates a suite of products spanning domain services, cloud hosting, app deployment, workflow automation, and developer tools.

When developing utility libraries, you'll often need to bundle static files like JSON configurations, text templates, or images. This guide demonstrates two professional approaches to include these files in your NuGet package:

1. Embedded Resources (Files compiled into the assembly)

2. Content Files (Files added to consumer projects)

Step 1: Project Setup (YourProject.csproj)

Base Configuration

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net9.0</TargetFramework>
    <PackageId>YourProject</PackageId>
    <Version>1.0.5</Version>
    <!-- Other metadata -->
  </PropertyGroup>
</Project>

Key Additions for Static Files

<ItemGroup>
  <!-- As Embedded Resource -->
  <EmbeddedResource Include="Phone/countries.json" />

  <!-- As Content File -->
  <None Include="Phone/countries.json" 
        Pack="True" 
        PackagePath="contentFiles/any/any/Phone/" />
</ItemGroup>

What These Do?

• EmbeddedResource: Bakes the file into your DLL

• None with Pack: Includes file in NuGet's contentFiles directory

Step 2: Accessing Embedded Resources

using System.Reflection;
using Newtonsoft.Json;

public class PhoneNumberOperation
{
    public List<CountryCode> CountryCodes { get; } = new();

    public PhoneNumberOperation()
    {
        var assembly = Assembly.GetExecutingAssembly();
        var resourceName = "YourProject.Phone.countries.json";

        using var stream = assembly.GetManifestResourceStream(resourceName) 
            ?? throw new FileNotFoundException($"Missing resource: {resourceName}");
        
        using var reader = new StreamReader(stream);
        CountryCodes = JsonConvert.DeserializeObject<List<CountryCode>>(reader.ReadToEnd())
            ?? new List<CountryCode>();
    }
}

Key Notes:

• Resource naming follows Namespace.Folder.Filename.extension

• Always validate null streams

• Consider using System.Text.Json for modern .NET projects

Step 3: Understanding Content Files

When consumers install your package, files in contentFiles will appear in their project under:

Project/
└── Phone/
    └── countries.json

Consumer Control:

• Files can be marked as Copy Always/Never

• Build action can be modified

Step 4: Package Verification

1. Build your package:

   dotnet pack --configuration Release
   

2. Inspect using:

   • NuGet Package Explorer (GUI tool)

   • Manual inspection by renaming .nupkg → .zip

Expected Structure:

├── lib
│   └── net9.0
│       └── YourProject.dll
└── contentFiles
    └── any
        └── any
            └── Phone
                └── countries.json

Pro Tips & Troubleshooting

1. Double-Check Resource Names

   var resources = assembly.GetManifestResourceNames();
   Console.WriteLine(string.Join("\n", resources));
   

2. ContentFiles Not Appearing?

   • Ensure the consumer's project SDK is Microsoft.NET.Sdk

   • Verify <IncludeContentInPack>true</IncludeContentInPack>

3. When to Use Which Method

   Embedded Resources	Content Files
   Internal configs	User-editable files
   Critical data	Example templates
   Small files	Larger assets

Complete Project File Reference

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net9.0</TargetFramework>
    <!-- Package Metadata -->
    <PackageId>YourProject</PackageId>
    <PackageReadmeFile>README.md</PackageReadmeFile>
  </PropertyGroup>

  <ItemGroup>
    <!-- Dependencies -->
    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
  </ItemGroup>

  <ItemGroup>
    <!-- Static Files -->
    <EmbeddedResource Include="Phone/countries.json" />
    <None Include="Phone/countries.json" 
          Pack="True" 
          PackagePath="contentFiles/any/any/Phone/" />
    <None Include="README.md" Pack="True" PackagePath="/" />
  </ItemGroup>
</Project>

Conclusion:

Including static files like JSON or text resources in NuGet packages elevates your library’s utility and flexibility. By leveraging embedded resources, you ensure critical files remain secure and directly accessible within your assembly. Meanwhile, content files empower consumers to customize configurations or reference external assets in their projects.

Always verify your package structure post-build and test consumption scenarios thoroughly. Whether you’re distributing localization files, templates, or configuration data, these techniques ensure your NuGet package delivers a polished, professional experience.

Empower your libraries—static files are no longer static limitations, but dynamic tools!

CONTACT:

I’m Kumar Bishojit Paul, the Founder and CEO of BIKIRAN. If you need further assistance, please leave a comment. I’m interested in helping you.

Got questions? Drop a comment below or reach out at contact@bikiran.com. Happy packaging!

🏢 About Bikiran

Bikiran is a software development and cloud infrastructure company founded in 2012, headquartered in Khulna, Bangladesh. With 15,000+ clients and over a decade of experience, Bikiran builds and operates a suite of products spanning domain services, cloud hosting, app deployment, workflow automation, and developer tools.

What Is Typography in Design?

Typography means arranging text to be attractive and easy to read. This involves choosing fonts, adjusting spacing, and organizing text in a clear hierarchy. Good typography guides the viewer’s eye, reinforces your message, and creates the right mood for your content.

The Evolution of Typography

Typography has a long history, evolving from early writing systems to today’s digital fonts. Ancient civilizations developed writing (like Egyptian hieroglyphs and Chinese calligraphy), and in the 15th century, Gutenberg’s printing press introduced movable type. Over the centuries, designers created new typefaces and printing techniques. In modern times, digital technology lets us design and use fonts easily on computers and screens. This means designers can fine-tune fonts instantly and maintain consistency across all media.

Incorporating Typography into Your Design

To use typography effectively, keep these principles in mind:

• Font vs. Typeface: A typeface is a family of related fonts (e.g., Arial), while a font is a specific style within that family (e.g., Arial Bold).

• Choose the Right Typeface: Pick a typeface that matches your brand’s personality. Serif fonts (with small decorative strokes) feel traditional or formal, while sans-serif fonts (clean, plain strokes) look modern and minimal. Script or decorative fonts add flair but should be used sparingly.

• Hierarchy and Readability: Use size and weight to guide attention. Headlines should be larger and bolder, while body text remains simple for easy reading. This creates a clear visual hierarchy and makes content more engaging.

• Spacing: Pay attention to kerning (space between letters) and leading (space between lines). Proper spacing prevents text from feeling cramped or too loose, improving readability and balance.

Key Elements of Typography

Successful typography combines several key elements:

• Typefaces and Fonts: The design of characters is the typeface, and fonts are specific variations (weight, size) of that typeface. Choose one or two complementary typefaces and use them consistently to keep the design cohesive.

• Color: Text color affects readability and mood. Ensure high contrast between text and background (for example, dark text on a light background) so content is easy to read. Colors also carry emotion: blue can feel trustworthy, red can feel urgent. Pick colors that support your brand’s message.

• Consistency: Use the same fonts, colors, and styles throughout your design. Consistent typography (across your website, marketing materials, etc.) creates a unified, professional look and strengthens brand identity.

• Contrast: Vary font size, weight, or color to create visual contrast and hierarchy. For example, a bold heading next to normal body text makes the heading pop. Good contrast helps important information stand out and guides the reader’s eye.

• Alignment: Text alignment (left, center, right, or justified) affects how easily people read. Left-aligned text is standard for paragraphs; center-aligned text works for short headings or calls to action. Choose alignment that suits your layout and maintains readability.

• Hierarchy: Establish which text is most important. Make titles and headings larger or bolder than the rest of the text. This way, readers can quickly find key sections and the overall flow of information is clear.

• Kerning (Letter Spacing): Kerning adjusts the space between individual letters. Proper kerning prevents letters from clashing or feeling too far apart, making text smooth and polished.

• Tracking (Overall Letter Spacing): Tracking applies spacing uniformly to a block of text. Increasing tracking can make titles and headlines more airy; decreasing it can fit more text in a line. Good tracking ensures words and lines feel balanced.

• Line Height (Leading): Line height is the vertical space between text lines. A comfortable line height (around 1.4 to 1.6 times the font size) prevents text from feeling cramped or too spread out, making paragraphs easier to read.

• Line Length: For body text, aim for about 50–75 characters per line (including spaces). Lines that are too long tire the reader’s eyes, while very short lines can feel choppy. An optimal line length makes reading flow naturally.

• White Space: Also known as negative space, white space is the empty area around text. Proper white space prevents clutter and highlights important elements. It gives your design room to breathe and makes content easier to scan.

Popular Fonts in 2025

Certain typefaces are trending in modern design. Here are some popular choices by category:

• Best for Logos:

  • Helvetica Now – A modern update of Helvetica that feels minimal and professional.

  • Gotham – A bold, geometric font known for a contemporary, trustworthy feel (famously used in Obama’s campaign posters).

  • Montserrat – A sleek, urban-inspired font that adds elegance to branding.

• Best for Landing Pages:

  • Raleway – An elegant, thin-stroke font that gives a refined look and makes headlines stand out.

  • PT Sans – A highly readable, friendly sans-serif with good spacing, ideal for clear content.

  • Avenir – A blend of classic and modern design; its smooth, geometric lines look polished on any page.

• Best for Mobile Apps:

  • Roboto – Designed for digital screens, offering excellent clarity and smooth readability on small devices.

  • Lato – A warm and professional sans-serif; its balanced spacing improves readability on mobile.

  • Inter – A modern font optimized for digital interfaces, maintaining clarity even at very small sizes.

• Best for Website Design:

  • Avenir – Modern and clean, it has smooth curves that enhance readability for both headlines and body text.

  • FF Kava – A stylish and unique font; its distinct shapes add personality while remaining highly legible.

  • Helvetica – A timeless classic known for its clarity and versatility, it works well in any context.

• Best for Social Media:

  • Bebas Neue – A bold, uppercase font that adds strong visual impact to social headlines.

  • Oswald – A modern, tall font that stands out in posts and banners.

  • Poppins – A clean, geometric sans-serif that looks fresh and contemporary on digital graphics. BIKIRAN Choose to use Poppins.

Why Typography Matters

Effective typography benefits your design and brand in many ways:

• Brand Identity: Typography gives your brand a voice. Consistent font choices convey personality and build recognition and trust.

• Readability: Good typography ensures text is easy to read. Appropriate fonts, sizes, and spacing make content accessible to all users.

• Visual Hierarchy: Typography organizes information by importance. By varying size and weight (for example, larger headings), you guide readers through your content logically.

• User Experience (UX): On websites and apps, clean, legible fonts make interfaces more intuitive. Sans-serif fonts are often used on screens for their clarity; this leads to a smoother user experience.

• Emotion and Tone: Fonts evoke feelings. A playful script feels fun, a bold uppercase feels urgent or powerful. The right style sets the tone and helps your message resonate emotionally.

• Accessibility: Thoughtful typography is inclusive. High-contrast text and clear fonts help users with visual impairments. Accessible typography ensures everyone can comfortably read your content.

How to Choose the Best Typeface for Your Website

When picking a font for your site, consider these tips:

• Align with Your Purpose: Think about your website’s goal and audience. Is it a formal business site, a creative blog, or an online store? Choose a typeface that fits the tone. For example, clean serifs or sans-serifs suit corporate sites, while more expressive fonts might fit creative brands.

• Focus on Readability: Prioritize clear, screen-friendly fonts. Sans-serifs like Roboto, Open Sans, or Poppins work well online. Avoid overly decorative or script fonts for body text. Always test your font on different devices to ensure it looks good and scales well.

• Size and Spacing: Use a comfortable base size (around 16px) for body text and larger sizes for headings. Maintain sufficient line spacing (about 1.5× the font size) so lines don’t feel cramped. Adjust kerning and tracking if needed to keep letters from running together or drifting apart.

• Limit Your Fonts: Stick to 2–3 fonts in your design. For example, use one for headings and another for body text (plus an optional third for accents). Too many fonts can make a site look disjointed. Make sure your chosen fonts harmonize and support your brand’s style.

• Test and Refine: After selecting a typeface, preview it with real content. Get feedback and check readability on desktop and mobile. Adjust styles or try alternatives if something feels off. Prioritize user comfort and clarity above all.

FAQs

What is the difference between a font and a typeface?

A typeface is the overall design of a set of characters (like Arial or Times New Roman). A font is a specific style within that typeface (such as Arial Bold or Times New Roman Italic). In short, the typeface is the family of designs, and the font is the individual style from that family.

How does typography influence user experience (UX)?

Typography shapes how easily users can read and navigate your content. Clear, legible fonts make information easy to absorb and can make your site feel intuitive. Conversely, poor typography (tiny fonts, low contrast, or overly decorative styles) can frustrate users. Good typography helps guide the user smoothly through the interface.

What are web-safe fonts?

Web-safe fonts are fonts that are commonly available across most devices and operating systems. Examples include Arial, Times New Roman, and Courier New. Using web-safe fonts (or setting fallback options) ensures that text appears consistently for all users, even if a custom font fails to load.

Should I use multiple fonts in my design?

It’s usually best to keep the number of fonts to two or three. Use one font for headings and another for body text, plus an optional third for accents or branding elements. This keeps the design clean and consistent. Using too many different fonts can make a layout feel cluttered and uncoordinated.

How do I ensure my typography is accessible?

Choose simple, easy-to-read fonts and use sufficient contrast with the background (for example, dark text on a light background). Provide enough letter and line spacing, and use clear sizes. Avoid very thin, tightly-spaced, or ornate fonts for large blocks of text. These practices help all readers, including those with visual impairments, comfortably read your content.

Conclusion

Typography is an essential part of building a strong brand identity. The right fonts do more than just look good – they set the tone, improve readability, and create a cohesive visual experience. By choosing fonts that match your brand’s personality and optimizing size, spacing, and contrast, you can create designs that engage viewers and communicate your message effectively.

CONTACT:

I’m H Moni, the UI/UX Designer of BIKIRAN. If you need further assistance, please leave a comment. I’m interested in helping you.

🏢 About Bikiran

Bikiran is a software development and cloud infrastructure company founded in 2012, headquartered in Khulna, Bangladesh. With 15,000+ clients and over a decade of experience, Bikiran builds and operates a suite of products spanning domain services, cloud hosting, app deployment, workflow automation, and developer tools.

.NET 9 is the latest iteration of Microsoft’s open-source development platform, packed with performance improvements, new C# features, and enhanced tools for cloud-native development. While it’s currently in preview, developers eager to experiment with its capabilities can install it on Ubuntu today. In this guide, we’ll walk through two straightforward methods to get .NET 9 up and running on your Ubuntu machine.

Why .NET 9?

Before diving into installation, here’s why you might want to explore .NET 9:

• Performance boosts: Optimized runtime and reduced memory usage.

• Cloud-native enhancements: Better integration with Kubernetes and containerized apps.

• C# 13 features: New language improvements for cleaner, more expressive code.

Note: .NET 9 is a preview release, so avoid using it in production environments.

Prerequisites

1. Ubuntu 20.04, 22.04, or later (check with lsb_release -a).

2. Terminal access and sudo privileges.

3. Basic familiarity with Linux package management.

Method 1: Install .NET 9 via APT Repository

STEP-1: Add Microsoft’s Package Feed

First, register Microsoft’s repository to access .NET packages:

wget https://packages.microsoft.com/config/ubuntu/$(lsb_release -rs)/packages-microsoft-prod.deb -O packages-microsoft-prod.deb  
sudo dpkg -i packages-microsoft-prod.deb  
rm packages-microsoft-prod.deb  

If you encounter issues, replace $(lsb_release—rs) with your Ubuntu version (e.g., 22.04).

STEP-2: Update Package Lists

Refresh your system’s package cache:

sudo apt-get update

STEP-3: Install the .NET 9 SDK

Install the SDK with apt (preview packages may have a specific naming convention):

sudo apt-get install dotnet-sdk-9.0

Verify the Installation

Confirm .NET 9 is installed correctly:

dotnet --info

# OR
# Version Check
dotnet --version

Troubleshooting Common Issues

1. “Package not found” error:

   • Ensure you’ve added the correct Microsoft repository.

   • Check for typos in the package name (e.g., dotnet-sdk-9.0-preview).

2. PATH issues:

   • Restart your terminal or run source ~/.bashrc after updating the PATH.

3. Preview instability:

   • Report bugs to the .NET GitHub repo.

Conclusion

You’re now ready to explore .NET 9 on Ubuntu! Whether you’re building microservices, web APIs, or experimenting with C# 13, the preview SDK gives you early access to cutting-edge features. Remember to check the official .NET 9 documentation for updates as the release progresses.

Happy coding! 🚀

CONTACT:

I’m Kumar Bishojit Paul, the Founder and CEO of BIKIRAN. If you need further assistance, please leave a comment. I’m interested in helping you.

🏢 About Bikiran

Bikiran is a software development and cloud infrastructure company founded in 2012, headquartered in Khulna, Bangladesh. With 15,000+ clients and over a decade of experience, Bikiran builds and operates a suite of products spanning domain services, cloud hosting, app deployment, workflow automation, and developer tools.

• Install .NET SDK (8.0 or newer recommended)

• Create a free NuGet.org account

Verify installation: After a successful installation, you could verify by the cmd/bash.

dotnet --version

SETP-2: Create a class library project

Using this command, a project named MyAwesomePackage will be created.

dotnet new classlib -n MyAwesomePackage
cd MyAwesomePackage

SETP-3: Open an Editor and Add your code

XML comments are necessary for proper documentation.

namespace MyAwesomePackage;

/// <summary>
/// Provides basic arithmetic operations
/// </summary>
public class Calculator
{
    /// <summary>
    /// Adds two integers
    /// </summary>
    /// <param name="a">First number</param>
    /// <param name="b">Second number</param>
    /// <returns>Sum of a and b</returns>
    public int Add(int a, int b) => a + b;
    
    // Add similar documentation for Multiply
}

SETP-4: Configure Package Metadata

Here is a basic project setup file, MyAwesomePackage.csproj

<Project Sdk="Microsoft.NET.Sdk">
	<PropertyGroup>
		<TargetFramework>net9.0</TargetFramework>
		
		<!-- Core Package Metadata -->
		<PackageId>MyAwesomePackage</PackageId>
		<Version>1.0.1</Version>
		<Authors>bishojit</Authors>
		<Company>BIKIRAN</Company>
		<Description>Utility functions for common operations</Description>
		<PackageTags>utilities helper tools</PackageTags>

		<!-- Recommended Additions -->
		<PackageProjectUrl>https://github.com/bikirandev/bikiran.utils</PackageProjectUrl>
		<RepositoryUrl>https://github.com/bikirandev/bikiran.utils.git</RepositoryUrl>
		<PackageLicenseExpression>MIT</PackageLicenseExpression>
		<IncludeSymbols>true</IncludeSymbols>
		<SymbolPackageFormat>snupkg</SymbolPackageFormat>
		
		<!-- Add below existing PackageTags -->
		<PackageReadmeFile>README.md</PackageReadmeFile>
	</PropertyGroup>

	<ItemGroup>
		<!-- Add NuGet.Protocol package reference -->
		<PackageReference Include="NuGet.Protocol" Version="6.13.2" />
	</ItemGroup>

	<ItemGroup>
		<None Include="README.md" Pack="true" PackagePath="\" />
	</ItemGroup>
</Project>

STEP-5: Build the Package

After developing all the operations, you need to build the package before publishing it.

dotnet build

STEP-6: Create NuGet Package

Make sure to fix all errors and warnings before publishing.

dotnet pack --configuration Release

STEP-7: Requirements before publishing

1. Add a LICENSE File (Required)

2. Add README.md (Required)

3. I repeat, must add XML comment documentation on each class.

4. Add Package Icon (Optional)

STEP-8: Publish to NuGet.org

• Log in > Click Upload (On Top Navigation Bar)

• Locate your file and upload it.

• After a successful upload, complete the form.

• After a few minutes, the Package will be approved.

Important Notes:

1. Versioning: Increment <Version> before each new release

2. The package ID must be unique across NuGet.org

3. Recommended: Use Semantic Versioning

4. For private feeds: Change --source to your feed URL

Next Steps:

1. Add documentation in README.md

2. Consider adding:

   • XML documentation comments

   • License file

   • Icon

   • Release notes

CONTACT:

I’m Kumar Bishojit Paul, the Founder and CEO of BIKIRAN. If you need further assistance, please leave a comment. I’m interested in helping you.

🏢 About Bikiran

Bikiran is a software development and cloud infrastructure company founded in 2012, headquartered in Khulna, Bangladesh. With 15,000+ clients and over a decade of experience, Bikiran builds and operates a suite of products spanning domain services, cloud hosting, app deployment, workflow automation, and developer tools.

The majority of developers find it challenging to utilize Docker on Linux server systems due to a lack of expertise. Deploying applications built with technologies like .NET, Next.js, Python, and Java can be particularly complex. This server agent provides a comprehensive API solution, simplifying the deployment process for developers.

REQUIREMENTS

1. Software Development Knowledge (.NET).

2. Docker Basic Knowledge

3. Linux Server Knowledge

STEP-01: Create a new ASP.NET Core Web API Project

Open up your terminal and run the following code to create your project. Feel free to personalize the project name instead of using “DockerInfoApi”.

dotnet new webapi -n DockerInfoApi
cd DockerInfoApi

STEP-02: Add Docker .NET NuGet Package

• To communicate between the Docker environment and this project, the Docker.DotNet NuGet Package is required.

• The Swashbuckle.AspNetCore NuGet Package is necessary for API management and provides an interactive API testing UI.

dotnet add package Docker.DotNet
dotnet add package Swashbuckle.AspNetCore
dotnet add package NuGet.Protocol

STEP-03: Project Setup

Here is a basic Project.csproj file that you can modify to meet your business requirements. The build and publish configurations are also included.

<Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
    <TargetFramework>net9.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>

    <!-- Add these configurations -->
    <OutputType>Exe</OutputType>
    <RuntimeIdentifier>linux-x64</RuntimeIdentifier>
    <SelfContained>true</SelfContained>
    <PublishSingleFile>true</PublishSingleFile>
    <PublishTrimmed>false</PublishTrimmed>
    <IncludeNativeLibrariesForSelfExtract>true</IncludeNativeLibrariesForSelfExtract>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="Docker.DotNet" Version="3.125.15" />
    <!-- Microsoft.AspNetCore.OpenApi is included in .NET 9.0 SDK - you can remove this explicit reference -->
    <PackageReference Include="NuGet.Protocol" Version="6.13.2" />
    <PackageReference Include="Swashbuckle.AspNetCore" Version="8.1.1" />
  </ItemGroup>

</Project>

STEP-04: Update Program.cs & Configure for Docker

Here is a sample file named Program.cs. You can add custom code to meet your business needs.

using Docker.DotNet;

var builder = WebApplication.CreateBuilder(args);

// Configure Docker client
var dockerUri = Environment.OSVersion.Platform == PlatformID.Unix 
    ? "unix:///var/run/docker.sock" 
    : "npipe://./pipe/docker_engine";
builder.Services.AddSingleton<IDockerClient>(new DockerClientConfiguration(new Uri(dockerUri)).CreateClient());

builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

var app = builder.Build();

if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.Run();

STEP-05: Create ContainersController.cs (With APIs)

Here is the first API for accessing the Docker environment. The controller provides four APIs listed below:

1. GET: /containers - Retrieve a list of all containers.

2. POST: /containers - Create a new container.

3. POST: /containers/:id/start - Start the specified container.

4. POST: /containers/:id/stop - Stop the specified container.

5. DELETE: /containers/:id - Remove the specified container.

using Docker.DotNet;
using Docker.DotNet.Models;
using Microsoft.AspNetCore.Mvc;

namespace DockerInfoApi.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class ContainersController : ControllerBase
    {
        private readonly IDockerClient _dockerClient;

        public ContainersController(IDockerClient dockerClient)
        {
            _dockerClient = dockerClient;
        }

        // List all containers
        [HttpGet]
        public async Task<IActionResult> GetContainers()
        {
            try
            {
                // List all containers
                var contListParams = new ContainersListParameters
                {
                    All = true
                };

                // Get the list of containers
                var containers = await _dockerClient.Containers.ListContainersAsync(contListParams);

                return Ok(containers);
            }
            catch (DockerApiException ex)
            {
                // Handle Docker API exceptions
                var message = $"Error retrieving containers: {ex.Message}";
                return StatusCode((int)ex.StatusCode, message);
            }
            catch (Exception ex)
            {
                // Handle other exceptions
                var message = $"Error retrieving containers: {ex.Message}";
                return BadRequest(message);
            }
        }

        // Create a new container
        //[HttpPost]
        // Coming Soon...

        // Start a container
        [HttpPost("{id}/start")]
        public async Task<IActionResult> StartContainer(string id)
        {
            try
            {
                // Start the container
                var contStartParams = new ContainerStartParameters { };
                var success = await _dockerClient.Containers.StartContainerAsync(id, contStartParams);

                return Ok($"Container {id} started successfully.");
            }
            catch (DockerContainerNotFoundException ex)
            {
                // Handle container not found exception
                var message = $"Container not found: {ex.Message}";
                return NotFound(message);
            }
            catch (Exception ex)
            {
                // Handle other exceptions
                var message = $"Error starting container: {ex.Message}";
                return BadRequest(message);
            }
        }

        // Stop a container
        [HttpPost("{id}/stop")]
        public async Task<IActionResult> StopContainer(string id)
        {
            try
            {
                // Stop the container
                var stopParams = new ContainerStopParameters
                {
                    WaitBeforeKillSeconds = 10
                };
                await _dockerClient.Containers.StopContainerAsync(id, stopParams);

                return Ok($"Container {id} stopped successfully.");
            }
            catch (DockerContainerNotFoundException ex)
            {
                // Handle container not found exception
                var message = $"Container not found: {ex.Message}";
                return NotFound(message);
            }
            catch (Exception ex)
            {
                // Handle other exceptions
                var message = $"Error stopping container: {ex.Message}";
                return BadRequest(message);
            }
        }

        // Remove a container
        [HttpDelete("{id}")]
        public async Task<IActionResult> RemoveContainer(string id)
        {
            try
            {
                // Remove the container
                var removeParams = new ContainerRemoveParameters
                {
                    Force = true,
                    RemoveVolumes = true
                };
                await _dockerClient.Containers.RemoveContainerAsync(id, removeParams);

                return Ok($"Container {id} removed successfully.");
            }
            catch (DockerContainerNotFoundException ex)
            {
                // Handle container not found exception
                var message = $"Container not found: {ex.Message}";
                return NotFound(message);
            }
            catch (Exception ex)
            {
                // Handle other exceptions
                var message = $"Error removing container: {ex.Message}";
                return BadRequest(message);
            }
        }
    }
}

STEP-06: Build and Publish the Project

Run the Project

dotnet run .

# A http://loclhost:5000 link will be generated after successful installation
# Browse URL: http://loclhost:5000/containers

After a successful run of the project, publish the project

dotnet publish -c Release

STEP-07: Prepare your Docker Environment to Test the APIs

Please check if your Docker is running on the OS.

# This command works on Windows, Linux, and macOS.
docker info > /dev/null 2>&1 && echo "Docker is running" || echo "Docker is not running"

Note: If Docker is not running, then install and run it. Docker Install

Creating a test container:

docker pull ubuntu
docker run -it ubuntu /bin/bash

# Test
# It returns the list of containers
docker ps

CONCLUSION:

The development of a Docker Server Agent with .NET simplifies the deployment process for developers who may find using Docker on Linux servers challenging. By following the outlined steps, developers can create a robust API to manage Docker containers efficiently. This guide provides a comprehensive approach, from setting up an ASP.NET Core Web API project to integrating necessary NuGet packages and configuring the Docker environment. By implementing these steps, developers can enhance their deployment capabilities, streamline container management, and leverage the full potential of Docker in their development workflows.

CONTACT:

I’m Kumar Bishojit Paul, the Founder and CEO of BIKIRAN. If you need further assistance, please leave a comment. I’m interested in helping you.

🏢 About Bikiran

Bikiran is a software development and cloud infrastructure company founded in 2012, headquartered in Khulna, Bangladesh. With 15,000+ clients and over a decade of experience, Bikiran builds and operates a suite of products spanning domain services, cloud hosting, app deployment, workflow automation, and developer tools.