Forem: Zahid Ahmed

Lets Setup K8s Cluster

Zahid Ahmed — Wed, 11 Feb 2026 17:42:45 +0000

0) Setting Hostnames [Master & Worker Nodes]

sudo hostnamectl set-hostname master.k8s.local
sudo hostnamectl set-hostname worker-one.k8s.local

sudo init 6

1) Update Hostfile [Master & Worker Nodes]

sudo tee -a /etc/hosts <<EOF
192.168.1.10 master.k8s.local
192.168.1.11 worker-one.k8s.local
EOF

2) Disabling Swap [Master & Worker Nodes]

sudo apt-get update

sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

sudo swapoff -a

3) Configure Kernel Modules [Master & Worker Nodes]

cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF

sudo modprobe br_netfilter
sudo modprobe overlay

4) Configure Kernel Parameters [Master & Worker Nodes]

cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables  = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward                 = 1
EOF

Apply sysctl params without reboot

sudo sysctl --system

Verify settings

sysctl net.bridge.bridge-nf-call-iptables net.bridge.bridge-nf-call-ip6tables net.ipv4.ip_forward
sysctl net.ipv4.ip_forward
sysctl net.bridge.bridge-nf-call-ip6tables
sysctl net.bridge.bridge-nf-call-iptables

5) Install Container Runtime [Master & Worker Nodes]

sudo apt-get update
sudo apt-get install -y containerd

sudo mkdir -p /etc/containerd
sudo containerd config default | sudo tee /etc/containerd/config.toml
sudo sed -i 's/            SystemdCgroup = false/            SystemdCgroup = true/' /etc/containerd/config.toml
cat /etc/containerd/config.toml

sudo systemctl restart containerd.service
sudo systemctl daemon-reload
sudo systemctl enable --now containerd
sudo systemctl status containerd
sudo containerd config dump

6) Install Kubernetes Management Tools [Master & Worker Nodes]

sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.35/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.35/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl
sudo systemctl enable kubelet

7) Initialization Kubernetes Cluster [Master Node Only]

sudo kubeadm init \
  --apiserver-advertise-address=192.168.10.2 \
  --pod-network-cidr=192.168.0.0/16 \
  --service-cidr=10.30.0.0/16 \
  --control-plane-endpoint=master.k8s.local:6443 \
  --upload-certs \
  --cri-socket /run/containerd/containerd.sock

8) Install Cilium Within Kubernetes Cluster [Master Node Only]

CILIUM_CLI_VERSION=$(curl -s https://raw.githubusercontent.com/cilium/cilium-cli/main/stable.txt)
CLI_ARCH=amd64
if [ "$(uname -m)" = "aarch64" ]; then CLI_ARCH=arm64; fi
curl -L --fail --remote-name-all https://github.com/cilium/cilium-cli/releases/download/${CILIUM_CLI_VERSION}/cilium-linux-${CLI_ARCH}.tar.gz{,.sha256sum}
sha256sum --check cilium-linux-${CLI_ARCH}.tar.gz.sha256sum
sudo tar xzvfC cilium-linux-${CLI_ARCH}.tar.gz /usr/local/bin
rm cilium-linux-${CLI_ARCH}.tar.gz{,.sha256sum}
cilium version
cilium install --version 1.16.2
kubectl get pod -n kube-system

9) Check Cluster Status [Master Node Only]

kubectl cluster-info

10) Scheduling Pods On Master [Master Node Only]

kubectl taint nodes --all node-role.kubernetes.io/master-

VM Stress Test Steps

Zahid Ahmed — Fri, 23 Jan 2026 19:41:29 +0000

Production Stress Test Documentation

This guide provides instructions for installing and running stress tests on AlmaLinux/Rocky Linux and Ubuntu systems using stress-ng.

1. Install Stress Tools On Alma/Rocky Linux

Run the following commands to install the necessary tools:

sudo dnf install epel-release -y
sudo dnf install stress-ng -y
sudo dnf install tmux -y

2. Run a Stress Test (20 Hours)

Use the following command to run a stress test for 20 hours:

stress-ng --cpu 0 --io 4 --vm 2 --vm-bytes 1G --hdd 1 --timeout 20h --metrics-brief

🔍 What this does

--cpu 0: Stresses all available CPU cores.
--io 4: Starts 4 I/O workers to create heavy I/O pressure.
--vm 2: Starts 2 memory workers.
--vm-bytes 1G: Allocates 1GB of RAM per vm worker (Total: 2GB).
--hdd 1: Starts 1 HDD worker (includes disk stress, safe temp files).
--timeout 20h: Runs the test for 20 hours.
--metrics-brief: Outputs a clean performance summary after completion.

3. Install Stress Tools On Ubuntu

Run the following command to install stress-ng:

sudo apt install stress-ng -y

4. Run a High-Load Stress Test

This command configures a specific high-load scenario (30 cores, 30GB RAM, 20 Hours):

stress-ng \
  --cpu 30 \
  --vm 30 \
  --vm-bytes 1G \
  --io 8 \
  --hdd 2 \
  --timeout 20h \
  --metrics-brief

🔍 Breakdown

--cpu 30: Stresses 30 CPU cores.
--vm 30: Starts 30 memory workers.
--vm-bytes 1G: Allocates 1GB RAM per worker (Total: 30GB).
--io 8: Starts 8 I/O workers.
--hdd 2: Starts 2 HDD workers.
--timeout 20h: Runs for 20 hours.
--metrics-brief: Shows a brief summary of metrics.

Install Golang On Ubuntu

Zahid Ahmed — Wed, 21 Jan 2026 18:56:52 +0000

This guide walks through a clean, system-wide installation of Go using the official binary, following industry best practices.

📂 Step 1: Download the Latest Go Binary

wget https://go.dev/dl/go1.25.6.linux-amd64.tar.gz

📂 Step 2: Install Go System-Wide

tar -C /usr/local -xzf go1.25.6.linux-amd64.tar.gz

📂 Step 3: Configure Environment Variables (Global Setup)

cat <<EOF >/etc/profile.d/go.sh
export GOROOT=/usr/local/go
export GOPATH=/opt/go
export PATH=\$PATH:\$GOROOT/bin:\$GOPATH/bin
EOF

chmod +x /etc/profile.d/go.sh

📂 Step 4: Create GOPATH Directory Structure

mkdir -p /opt/go/{bin,src,pkg}

📂 Step 5: Reload Environment Variables

source /etc/profile

📂 Step 6: Verify the Installation

go version

Happy coding with Go 🚀

Setting Up a Kubernetes With CRIO (I)

Zahid Ahmed — Sun, 29 Dec 2024 05:39:01 +0000

1. Setting Hostnames (Master & Worker Nodes)

sudo hostnamectl set-hostname "master-one.k8s.local"

sudo init 6

2. Update Hostfile

sudo nano /etc/hosts
#Add the following list in the end of line
172.16.1.100 master-one.k8s.local
172.16.1.101 worker-one.k8s.local
172.16.1.102 worker-two.k8s.local

3. Disabling Swap (Master & Worker Nodes)

sudo apt-get update

sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

sudo swapoff -a

4. Configure Modules (Master & Worker Nodes)

cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF

sudo modprobe br_netfilter
sudo modprobe overlay

5. Configure Networking (Master & Worker Nodes)

cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-iptables  = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward                 = 1
EOF

sudo sysctl --system
sysctl net.ipv4.ip_forward
sysctl -w net.ipv4.ip_forward=1

6. Install Kubernetes Management Tools (Master & Worker Nodes)

sudo apt-get update
sudo apt-get install -y ca-certificates curl
sudo apt-get install -y apt-transport-https ca-certificates curl
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.31/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.31/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl
sudo systemctl enable kubelet

7. Install Container runtime (Master & Worker Nodes)

CRIO_VERSION=v1.31

mkdir -p /etc/apt/keyrings/

apt-get update
apt-get install -y software-properties-common curl
curl -fsSL https://pkgs.k8s.io/addons:/cri-o:/stable:/$CRIO_VERSION/deb/Release.key | \
    gpg --dearmor -o /etc/apt/keyrings/cri-o-apt-keyring.gpg

echo "deb [signed-by=/etc/apt/keyrings/cri-o-apt-keyring.gpg] https://pkgs.k8s.io/addons:/cri-o:/stable:/$CRIO_VERSION/deb/ /" | \
    tee /etc/apt/sources.list.d/cri-o.list

apt-get update
apt-get install -y cri-o
systemctl start crio.service
sudo systemctl status crio
sudo systemctl daemon-reload
sudo systemctl enable crio --now

8. Initialization Kubernetes Cluster (Master Node Only)

sudo kubeadm init \
  --pod-network-cidr=10.10.0.0/16 \
  --upload-certs \
  --control-plane-endpoint=master-one.k8s.local

8. Install Cilium Within Kubernetes Cluster (Master Node Only)

CILIUM_CLI_VERSION=$(curl -s https://raw.githubusercontent.com/cilium/cilium-cli/main/stable.txt)
CLI_ARCH=amd64
if [ "$(uname -m)" = "aarch64" ]; then CLI_ARCH=arm64; fi
curl -L --fail --remote-name-all https://github.com/cilium/cilium-cli/releases/download/${CILIUM_CLI_VERSION}/cilium-linux-${CLI_ARCH}.tar.gz{,.sha256sum}
sha256sum --check cilium-linux-${CLI_ARCH}.tar.gz.sha256sum
sudo tar xzvfC cilium-linux-${CLI_ARCH}.tar.gz /usr/local/bin
rm cilium-linux-${CLI_ARCH}.tar.gz{,.sha256sum}
cilium version
cilium install --version 1.16.2
kubectl get pod -n kube-system

9. Check Cluster Status (Master Node Only)

kubectl cluster-info

Apache Kafka with Docker

Zahid Ahmed — Wed, 25 Dec 2024 20:10:51 +0000

Apache Kafka, a robust distributed streaming platform, is essential for building dynamic data pipelines and real-time applications. Pairing it with Docker makes setting up Kafka seamless, empowering developers to explore and innovate effortlessly. In this guide, we’ll dive into the step-by-step process of running Apache Kafka with Docker

Create Docker Compose File

https://github.com/zahido/Docker.git

This docker-compose.yml file contains kafka, zookeeper & GUI redpanda.

Spin Docker Compose

docker-compose up -d

Verify Container is Running

docker ps

Create Topic

docker exec -it <kafka-container-id> /opt/kafka/bin/kafka-topics.sh --create --zookeeper zookeeper:2181 --replication-factor 1 --partitions 1 --topic my-topic

Replace with the actual container ID of the Kafka container (you can find it using docker ps).

Produce & Consume Messages

docker exec -it <kafka-container-id> /opt/kafka/bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic my-topic --from-beginning

Replace with the actual container ID of the Kafka container.

You’ve successfully set up and run Apache Kafka on Docker well done! This guide offers you a straightforward yet effective way to experiment with Kafka. 🚀

Docker Architecture In Easy Mode

Zahid Ahmed — Fri, 19 Apr 2024 18:52:51 +0000

- Explore the intricate design and comprehensive operational mechanics of Docker

When we execute command using the Docker CLI to create a container, the docker client converts the command into a RESTful API, which is then passed to the Docker Daemon.

Docker Daemon on receiving the instruction, first checks if the image provided is already available on the local system. If it is not, the image is downloaded from the docker registry, and once the image is downloaded

It makes a call to the containerd to start the container. containerd is responsible for converting the image that was downloaded into an OCl compliance bundle.

It then passes the bundle to containerd-shim, which in turn calls the runC to start container and interacts with the namespaces and groups.

while runC utilizes libcontainer under the hood to interact with the Linux kernel and manage containers

That's how a container gets created.

Docker Management Tools That's Save Time & Effort

Zahid Ahmed — Sun, 04 Feb 2024 16:59:32 +0000

LazyDocker is a simple command line interface (CLI) tool that simplifies the management of Docker. LazyDocker allows you to execute regular Docker actions like initiating, halting, restarting, and eliminating containers using just one instruction. LazyDocker also simplifies the process of checking logs, removing containers and images that are not being used, and customize metrics.

Bootup In Docker:

$ docker run --rm -it -v \
/var/run/docker.sock:/var/run/docker.sock \
-v /yourpath:/.config/jesseduffield/lazydocker \
lazyteam/lazydocker

Don't forget to change /yourpath to an actual path you created to store lazydocker's config

$ lazydocker [ launch lazy ]

## Don’t Like To Be Lazy Try This One:

CTOP gives a brief and compressed summary of up-to-date measurements for multiple containers.

Debian/Ubuntu Installations:

sudo apt-get install ca-certificates curl gnupg lsb-release
curl -fsSL https://azlux.fr/repo.gpg.key | sudo gpg --dearmor -o /usr/share/keyrings/azlux-archive-keyring.gpg
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/azlux-archive-keyring.gpg] http://packages.azlux.fr/debian \
  $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/azlux.list >/dev/null
sudo apt-get update
sudo apt-get install docker-ctop

$ ctop [ launch command  ]

If you’re looking for a way to save time and effort managing Docker these tools's for you.

Nushell: Get Fun With Terminal

Zahid Ahmed — Wed, 10 Jan 2024 14:56:42 +0000

Dive into a cutting-edge rust-powered shell that turns your terminal journey into a vibrant blend of excitement and unparalleled productivity!

Install On Ubuntu



$ curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
$ sudo apt install build-essential
$ sudo apt install pkg-config libssl-dev
$ cargo install nu

Start Nushell



$ nu

Nushell Commands



$ ls | where type == "dir"
$ ls | where type == "file" 
$ ls | sort-by modified 
$ ls | sort-by modified | reverse
$ ps {Information about currently running processes}
$ sys {Displays information about the system}
$ sys | get host | table
$ open composer.json 
$ ls **/composer.json
$ open client.db | schema | get tables. variables {Check sqlite schema}
$ http get "https://github.com/tauseedzaman/Zshop/blob/main/composer.json" {perform an HTTP GET request to fetch the content}
$ docker ps --format="{{ json . }}" | lines | each { from json } | transpose
$ docker ps --format="{{ json . }}" | lines | each { from json }

Deploying a Next.js App On AWS EC2 Guide

Zahid Ahmed — Tue, 21 Nov 2023 10:06:34 +0000

Before diving into the deployment process, let’s highlight some key benefits of hosting your Next.js app on the AWS cloud:

1) Scalability: AWS provides the flexibility to scale your EC2 instances based on demand. This means your Next.js app can handle traffic spikes without compromising performance.

2) Reliability: AWS offers a highly reliable infrastructure with a Service Level Agreement (SLA) that ensures your application is available and operational when your users need it.

3) Global Reach: Deploying on AWS allows you to choose data centers around the world, reducing latency and providing a faster experience for users across different geographical locations.

4) Security: AWS provides robust security measures, including firewalls, encryption, and identity management, ensuring that your Next.js app and user data are well-protected.

5) Cost Efficiency: AWS EC2 instances offer a pay-as-you-go model, allowing you to control costs by selecting the appropriate instance type and scaling resources as needed.

Step-by-Step Deploying Next.js App On AWS EC2

$ Step 1: Sign in to your AWS Management Console

$ Step 2: Launch an EC2 Instance

Choose an Instance Type. You can select the type of machine, number of vCPUs, and memory that is required.

Create a new SSH Key Pair

Now under Network Settings, Choose the default VPC with Auto-assign public IP in enable mode. I will select an existing security group and will make sure under the Inbound rules of my Devops-SG, HTTP, and HTTPS ports are open. Click on Save rules to proceed.

Modify rest of the settings as per your need and click on Launch Instance

On the next screen you can see a success message after the successful creation of the EC2 instance, click on Connect to instance button. Instance wizard will open, go to SSH client tab and copy the provided chmod and SSH command.

$ Step 3: Install Dependencies



# sudo apt update
# curl -sL https://deb.nodesource.com/setup_16.x | sudo -E bash -
# sudo apt-get install -y nodejs
# node -v
# sudo npm install -g npm@latest
# npm -v
# git clone https://github.com/zahido/nextjs-apps.git
# cd nextjs-apps/
# npm install
# npm run build

$ Step 4: Install PM2



# sudo npm install pm2 -g

$ Step 5: Run Next.js via PM2



# pm2 start npm --name nextjs-apps -- run start -- -p 3000
# pm2 list nextjs-apps
# pm2 stop nextjs-apps
# pm2 start nextjs-apps
# pm2 restart nextjs-apps
# pm2 delete nextjs-apps

> Enter the EC2 Instance’s public IP along with port number 3000 in a web browser.

Conclusion
This post has demonstrated the deployment of a Next.js App on AWS EC2 instance. "Together, let's embark on a voyage into the dynamic universe of DevOps, uncovering exhilarating insights. Your active participation is truly valued on this exploration."

AWS Deploy Single Node Kubernetes Cluster

Zahid Ahmed — Wed, 20 Sep 2023 16:07:30 +0000

Instead of a full-blown Kubernetes cluster, the single node instances are best for both development and testing. Let's go with lightweight Kubernetes managed by Canonical, Microk8s.

MicroK8s is the easiest and fastest way to get Kubernetes up and running. Experiment with the latest upstream features and toggle services on and off. Seamlessly move your work from dev to production. 😎✌🏻

Install MicroK8s on Ubuntu Server

Install MicroK8s:

$ sudo snap install microk8s --classic

Check Status:

$ microk8s status --wait-ready

Add Your Current User To MicroK8s Group:

$ sudo usermod -a -G microk8s $USER
$ sudo mkdir ~/.kube && sudo chown -R $USER ~/.kube
$ sudo newgrp microk8s

Enable Services That You Will Need:

$ microk8s enable dns
$ microk8s enable dashboard
$ microk8s enable storage
$ microk8s enable ingress
$ microk8s enable gpu
$ microk8s enable istio
$ microk8s enable registry

To Disable Any Of These Services Later:

$ microk8s disable dns

Check the Status Of Kubernetes Services:

$ microk8s kubectl get all --all-namespaces

To login web-based dashboard generate a token with the following commands, and then paste it into login prompt:

$ token=$(microk8s kubectl -n kube-system get secret | grep default-token | cut -d " " -f1)
$ microk8s kubectl -n kube-system describe secret $token

Get Rid Of Microk8s & Use Kubectl:

$ alias kubectl="microk8s kubectl"

Lookup Pod & Node Details:

$ kubectl get nodes
$ kubectl get pods -o wide

Start & Stop MicroK8s Service:

$ microk8s start
$ microk8s stop

Uninstall MicroK8s

$ sudo snap remove microk8s

Mastering In Production-Grade Docker Compose File

Zahid Ahmed — Wed, 23 Aug 2023 19:57:49 +0000

As applications evolve and embrace microservices architecture, orchestrating containers in a production environment becomes critical. Docker Compose, a powerful tool for defining multi-container applications, can play a pivotal role in streamlining deployments. I'll guide you through the best practices for crafting a robust and scalable 'docker-compose.yml' file tailored for a production environment.

1. Version with Care

Specify the appropriate Docker Compose version in your file. However, stick to a version that is well-tested and supported in your production environment to avoid compatibility issues.

version: '3.8'

2. Separate Configuration Files

Divide your docker-compose.yml into multiple configuration files. This promotes modularity and allows for easier management of complex deployments.

docker-compose.yml
version: '3.8'
services:
  web:

docker-compose.prod.yml
version: '3.8'
services:
  database:

3. Tuned Resource Allocation

Allocate resources thoughtfully based on your application's requirements. Properly configure CPU and memory limits to prevent resource contention and ensure consistent performance.

services:
  web:
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: '512M'

4. Use Named Volumes

Employ named volumes to ensure persistent storage across container restarts and updates. This is crucial for databases and data that need to survive container changes.

services:
  database:
    volumes:
      - db-data:/var/lib/mysql

volumes:
  db-data:

5. Security First

Implement security best practices by avoiding hardcoding sensitive information. Utilize environment variables, Docker secrets, or external configuration files.

services:
  web:
    environment:
      - DATABASE_URL=${DATABASE_URL}
    secrets:
      - db_password

secrets:
  db_password:
    file: ./db_password.txt

6. Horizontal Scaling

Design your services with scalability in mind. Leverage Docker Compose's scale feature to easily replicate services when required.

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

Service Discovery and Load Balancing Implement a service discovery mechanism and load balancing to ensure high availability and distribute traffic efficiently.

services:
  web:
    networks:
      - frontend
    deploy:
      replicas: 3
      update_config:
        parallelism: 2
        delay: 10s
        order: start-first

8. Healthchecks for Reliability

Incorporate healthchecks to verify service health and aid in automated recovery. This helps ensure the availability of your application.

services:
  web:
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost"]

9. Logging and Monitoring

Integrate a centralized logging and monitoring solution to gather insights into your application's behavior and performance.

10. Regular Backups

Implement a backup strategy for data stored within your containers, especially databases. Schedule periodic backups to prevent data loss.

11. Automated Deployment

Use continuous integration and continuous deployment (CI/CD) pipelines to automate the deployment process, ensuring consistency and minimizing human error.

12. Regular Testing

Test your docker-compose.yml file and associated configurations in a staging environment that closely resembles the production setup to catch issues before they impact users.

Conclusion

A production-grade 'docker-compose.yml' file plays a pivotal role in ensuring the stability, scalability, and security of your containerized applications. By adhering to these best practices, you'll be well-equipped to manage the intricacies of deploying and maintaining multi-container applications in a production environment.

Best Practices for Writing a Dockerfile

Zahid Ahmed — Wed, 23 Aug 2023 19:37:40 +0000

Since I have been working with Docker for a long time, I decided to share some of my experience with you on best practices to develop better Containers.

1. Start with a Minimal Base Image

Choosing the right base image is crucial. Opt for a minimal image such as Alpine Linux or Debian slim. This reduces the attack surface and minimizes the container size, leading to faster image builds, downloads, and deployments.

2. Update and Upgrade Packages

Always run package updates and upgrades in your Dockerfile. This ensures that your container starts with the latest security patches and software updates, reducing vulnerabilities.

3. Use a Clear Directory Structure

Organize your project files within the container using a clear directory structure. This aids in readability and maintenance.

4. Copy Only What You Need

Minimize the data you copy into the image. Use .dockerignore to exclude unnecessary files from being copied, reducing the image size and build time.

5. Combine RUN Commands

Combine multiple RUN commands into a single command using logical operators (&&). This reduces the number of image layers, resulting in a smaller image.

6. Use Multi-Stage Builds

Utilize multi-stage builds to create intermediate build images and extract only necessary artifacts into the final image. This helps maintain a small final image size.

7. Set Environment Variables

Use ENV to set environment variables that configure your application's behavior. This makes your Dockerfile more configurable and adaptable across different environments.

8. Keep Layers In Logical Order

Arrange commands in your Dockerfile in a way that maximizes layer reuse. Commands that change frequently (like copying application code) should come after those that change infrequently (like installing dependencies).

9. Use Healthchecks

Incorporate healthchecks to monitor the container's health and ensure that your application is running as expected.

10. Secure Your Dockerfile

Avoid exposing sensitive information like credentials directly in the Dockerfile. Use build-time variables or secrets managed by the orchestration platform.

11. Document Your Dockerfile

Add comments explaining the purpose of each command and any assumptions you're making. This aids in collaboration and troubleshooting.

12. Test Your Dockerfile

Regularly test your Dockerfile by building and running the container locally. Ensure that it behaves as expected before pushing to a repository.

Conclusion

Writing an effective Dockerfile is an art that requires attention to detail and a deep understanding of both the application and containerization concepts. By following these best practices, you'll create Dockerfiles that lead to optimized images, faster build times, improved security, and a smoother development process.