DEV Community: BlacOrpheus

Docker-Based Static Website Deployment: A Comprehensive Guide

BlacOrpheus — Sun, 25 Jan 2026 16:43:08 +0000

Prerequisites

AWS Account
AWS CLI installed and configured (aws configure)
Docker installed locally
Git installed locally
Basic knowledge of HTML/CSS (or static site generator like Hugo, Jekyll)

Introduction

In today's fast-paced digital landscape, delivering websites that are both performant and reliable is crucial. Static websites have emerged as a powerful solution for many use cases—blogs, documentation, marketing sites, and portfolios—offering lightning-fast load times, enhanced security, and simplified maintenance. However, deploying and managing these websites consistently across different environments can still present challenges.

Enter Docker, the containerization platform that has revolutionized how we build, ship, and run applications. By combining static websites with Docker containers, we create a deployment strategy that delivers unprecedented consistency, portability, and scalability. Whether you're deploying to your local machine, a development server, or a cloud production environment, Docker ensures your website behaves identically everywhere.

This comprehensive guide takes you from zero to production-ready deployment, covering everything from creating a simple static website to implementing advanced Docker configurations for real-world scenarios. You'll learn not just the "how" but also the "why" behind each decision, equipping you with knowledge that extends far beyond following a recipe.

Why Docker for Static Websites?

Consistency Across Environments: No more "it works on my machine" problems. Your website runs identically from development to production.
Simplified Deployment: Package your entire website—content, web server, and configuration—into a single, portable container.
Version Control for Environments: Track changes to your website environment alongside your code changes.
Resource Efficiency: Lightweight containers use minimal resources compared to traditional virtual machines.
Scalability: Easily replicate containers to handle increased traffic or deploy across multiple regions.
Security Isolation: Containers provide process and filesystem isolation from the host system.

What You'll Accomplish

By the end of this guide, you will:

Create a production-ready static website with modern HTML, CSS, and JavaScript
Build optimized Docker images using industry best practices
Configure Nginx for maximum performance and security
Set up both development and production environments
Deploy your containerized website to cloud platforms
Implement monitoring, logging, and maintenance strategies
Apply security hardening techniques to your deployment

Whether you're a developer looking to streamline your deployment process, a DevOps engineer seeking consistent environments, or a business owner wanting reliable website hosting, this guide provides the practical knowledge you need. We'll start with the fundamentals and progressively build up to enterprise-grade deployment patterns, ensuring you have a solid foundation that can grow with your needs.

Let's begin by setting up our project and understanding the core components that make Docker-based static website deployment so effective.

Step One: Create a Directory

First, create a project directory to organize your HTML files and Docker configuration. You can use either your command line or IDE. For this example, we'll create a directory named "docker-static-site" and navigate into it:

mkdir docker-static-site
cd docker-static-site

Step Two: Acquiring the Nginx Base Image from Docker Registry

To containerize our static website, we'll leverage the Nginx web server, a lightweight, high-performance solution ideal for serving static content. The first step involves retrieving the official Nginx Docker image from the Docker Hub registry. This pre-configured image provides a standardized foundation, ensuring consistent behavior across all deployment environments. Execute the following command to pull the latest stable version of the Nginx image to your local machine:

docker pull nginx

To verify that we pulled the latest image:

docker images

Step Three: Building the Primary Web Document: index.html

The index.html file represents the architectural blueprint of your website. It defines the document's skeletal structure using HTML elements, establishes semantic organization for content accessibility, and sets up the necessary linkages to supporting resources like stylesheets and scripts. This foundational file will eventually be served by Nginx within our Docker container as the default landing page.

Step Four: Building a Custom Container Image via Dockerfile

Container images are constructed from declarative Dockerfiles that specify the complete runtime environment. Begin by creating a file named "Dockerfile" in your project's root directory—maintaining this exact filename is critical as Docker's build command automatically searches for it. This configuration orchestrates several operations: selecting an official base image, copying your website files into the container, exposing network ports, and defining the default process. The following example illustrates a production-ready Dockerfile optimized for serving static content:

With the Dockerfile defined, we can now execute the build process to create our custom container image. The docker build command compiles the instructions in your Dockerfile into a runnable image, while the -t flag tags it with a human-readable identifier for easier reference. Run the following command in your project directory:

docker build -t webserver .

Step Five: Deploy the Container as a Running Service

Transition from a static image to a live web service by instantiating a container. The run command orchestrates multiple operations: creating the container filesystem, configuring networking, and executing the default process defined in the image. Deploy with these flags to enable background operation and external access:

docker run -it -d -p 8080:80 webserver

To verify your container is running correctly, open a web browser and navigate to http://localhost:8080/

Step Six: Pushing the Container Image to AWS ECR

Before proceeding, ensure your AWS CLI is properly configured with aws configure. Then authenticate Docker with your ECR registry by running (replace placeholders with your region and account ID).

To store your Docker image in AWS Elastic Container Registry (ECR), execute the following commands:

aws ecr get-login-password --region us-east-1 \
| docker login --username AWS --password-stdin <ACCOUNT_ID>.dkr.ecr.us-east-1.amazonaws.com

Step Seven: Tag and Push the Image

docker tag blog-image:latest <ACCOUNT_ID>.dkr.ecr.us-east-1.amazonaws.com/webserver:latest
docker push <ACCOUNT_ID>.dkr.ecr.us-east-1.amazonaws.com/webserver:latest

Step Eight: Conclusion

By following this guide, you have successfully containerized a static website using Docker and deployed it to AWS. You've transformed static files into a portable, scalable container that can run consistently across any environment—from local development to cloud production. This foundation enables reliable deployments, simplified maintenance, and scalable web hosting.

Chidubem Chinwuba is a dedicated Cloud/DevOps Engineer. He possesses a deep passion for technology and its transformative potential across industries. Overall, Chidubem is driven by his passion for technology and his aspiration to make a meaningful impact in the Cloud/DevOps domain. He is excited to continue his professional growth and contribute to projects that shape the future of technology.

Deploying an AWS EKS Cluster Using Terraform: A Step-by-Step Guide

BlacOrpheus — Thu, 15 Jan 2026 10:05:17 +0000

Introduction

In today's cloud-native landscape, Kubernetes has become the de facto standard for container orchestration, and Amazon Elastic Kubernetes Service (EKS) provides a managed Kubernetes service that simplifies cluster management. When combined with Terraform, HashiCorp's Infrastructure as Code (IaC) tool, you can achieve reproducible, version-controlled, and automated Kubernetes infrastructure deployment.

This comprehensive guide will walk you through deploying a production-ready AWS EKS cluster using Terraform, covering everything from initial setup to operational best practices.

Prerequisites

Before beginning, ensure you have the following:

AWS Account with appropriate IAM permissions
AWS CLI installed and configured
Terraform (v1.0+) installed
kubectl for Kubernetes cluster interaction
Basic understanding of AWS services, Kubernetes, and Terraform

Architecture Overview

Our deployment will create:

A VPC with public and private subnets across multiple Availability Zones
EKS control plane managed by AWS
Managed node groups for worker nodes
Necessary IAM roles and security groups
Network components (NAT Gateway, Internet Gateway, Route Tables)

Efficient EKS Cluster Provisioning with Terraform's Modular Design

This implementation employs a Terraform module containing pre-defined configurations to simplify Amazon EKS cluster creation, demonstrating infrastructure-as-code efficiency.

Step 1: Prepare Your Environment - Install Terraform

Begin by installing Terraform locally to set up your development environment.

brew install terraform

Secondly, install the AWS CLI:

brew install awscli

Thirdly, install kubectl:

brew install kubernetes-cli

For installation on other operating systems, see the official documentation:

Terraform: Installation guide

AWS CLI: Installation instructions

kubectl: Installation documentation

Step 2: Configure AWS CLI Access

Run

aws configure

to set up authentication with your AWS account. You'll need to enter:

AWS Access Key ID
AWS Secret Access Key
Default region: us-east-1

Terraform will use these credentials to create and manage your AWS resources.

Step 3: Prepare the Code Environment

We'll utilize the terraform-aws-modules/eks/aws Terraform module for this implementation.

data "aws_availability_zones" "available" {}

resource "aws_vpc" "main" {
 cidr_block = "10.0.0.0/16"

 tags = {
   Name = "main-vpc-eks"
 }
}

resource "aws_subnet" "public_subnet" {
 count                   = 2
 vpc_id                  = aws_vpc.main.id
 cidr_block              = cidrsubnet(aws_vpc.main.cidr_block, 8, count.index)
 availability_zone       = data.aws_availability_zones.available.names[count.index]
 map_public_ip_on_launch = true

 tags = {
   Name = "public-subnet-${count.index}"
 }
}

resource "aws_internet_gateway" "main" {
 vpc_id = aws_vpc.main.id

 tags = {
   Name = "main-igw"
 }
}

resource "aws_route_table" "public" {
 vpc_id = aws_vpc.main.id

 route {
   cidr_block = "0.0.0.0/0"
   gateway_id = aws_internet_gateway.main.id
 }

 tags = {
   Name = "main-route-table"
 }
}

resource "aws_route_table_association" "a" {
 count          = 2
 subnet_id      = aws_subnet.public_subnet.*.id[count.index]
 route_table_id = aws_route_table.public.id
}

module "eks" {
 source  = "terraform-aws-modules/eks/aws"
 version = "~> 20.31"

 cluster_name    = "sage-nodes"
 cluster_version = "1.31"

 # Optional
 cluster_endpoint_public_access = true

 # Optional: Adds the current caller identity as an administrator via cluster access entry
 enable_cluster_creator_admin_permissions = true

 eks_managed_node_groups = {
   sage-nodes = {
     instance_types = ["t3.medium"]
     min_size       = 1
     max_size       = 3
     desired_size   = 2
   }
 }

 vpc_id     = aws_vpc.main.id
 subnet_ids = aws_subnet.public_subnet.*.id

 tags = {
   Environment = "dev"
   Terraform   = "true"
 }
}

Step 4: Apply Terraform Configuration
Begin by initializing Terraform to download dependencies, then apply the configuration to create your EKS cluster infrastructure.

terraform init

Post-initialization, generate a plan to review infrastructure changes.

terraform plan

Wait a few minutes for all resources to be created.

Step 5 – Configure kubectl Access

Run the following command:

aws eks --region us-east-1 update-kubeconfig --name example

At this point, verify that the login to the cluster was successful.

kubectl config current-context

Step 6 – Manage the Cluster

Use the following command to view all nodes in the cluster:

kubectl get nodes

To validate the cluster, deploy an NGINX instance.

kubectl run --port 80 --image nginx nginx

To see its status:

kubectl get pods

Now, establish a tunnel from your local environment to the pod.

kubectl port-forward nginx 3000:80

Step 7 – Resource Cleanup

To destroy the resources created in this session, execute the following command:

terraform destroy

Ensure to destroy the created resources to avoid incurring huge financial bills from AWS.

Conclusion

By completing this guide, you've established a production-ready AWS EKS cluster deployment using Terraform's infrastructure-as-code approach. This foundation enables consistent, version-controlled Kubernetes infrastructure management across all environments.

Deploying a Node.js Application on AWS

BlacOrpheus — Sat, 23 Nov 2024 18:59:55 +0000

Synopsis
In this blog post, I’ll walk you through the steps to deploy a Node.js application on the AWS cloud. Along the way, I’d demonstrate how to leverage Termius, a versatile SSH platform that works on both mobile and desktop. Additionally, I’ll guide you on how to communicate seamlessly with a GitHub repository. Let’s dive in!

Backstory
Deploying a Node.js Application on AWS means putting your web app on a super reliable and fast platform. It’s like giving your app a strong backbone. It can handle lots of users without slowing down. AWS also gives you handy tools to make deploying and managing your app easier. This way, you can spend more time making your app cool and less time worrying about technical stuff. So, using AWS for deployment helps make your web app strong, reliable, and ready for anything.

Requirements
An AWS Account
Termius (SSH platform for Mobile and Desktop)
Basic Understanding of Linux
A GitHub Account

Node.js

Node.js is a runtime environment that allows you to run JavaScript code outside of a web browser. It is built on the V8 JavaScript engine, which is the same engine that powers Google Chrome. Node.js enables you to execute JavaScript on the server-side, making it possible to build web applications, APIs, and other types of software using JavaScript.

Termius

Termius is a cross-platform SSH client that allows users to securely connect to remote servers, manage files, and execute commands over SSH (Secure Shell) protocol. It’s available for both mobile devices and desktop computers, providing a convenient way to access and manage remote servers from various platforms.

Express

Express is a web application framework for Node.js. It provides a robust set of features to help you build web applications and APIs quickly and efficiently.

Procedure
This process can easily be replicated by anyone on their local machine by following closely with the instructions that would be listed below.

Create an AWS instance Login to your AWS console and create an ec2 instance, select an Ubuntu OS image and ensure the Amazon Machine Image (AMI) and instance type (t2.micro) fall under the free tier to avoid incurring charges.

Create a new key pair You can also use an existing one if available, click on create a security group and allow SSH traffic from the recently created security group, finally click on “Launch instance”.

Connecting the ec2 instance to termius Take note of the instance public ip address and the user name as they would be integral in connecting to Termius. If you do not have Termius, you could download it here.

Next I created a new host on Termius and input my ec2 public IP address and select a key pair by using the already created file from the AWS console. Finally I click on the arrow on the top right corner of the screen.

Click on the node-server icon, lick on “Add and continue” to connect to your instance.

Connecting to GitHub Create a new directory called “node-server” via the terminal.

Create an ssh key generator to connect to your GitHub account.

Get the created ssh key, copy it and head to the following GitHub Repo: https://github.com/BlacOrpheus/Dating-App. Click on settings and click on deploy keys

Add your keys there and allow write access.

Clone your repository into your ec2 instances

Click on code and copy the SSH code.

On Termius type the following code:

git clone git@github.com:BlacOrpheus/Dating-App.git

Proceed to install node on your AWS EC2 instances with the following commands:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.5/install.sh | bash

. ~/.nvm/nvm.sh


nvm install --lts

Installation of Dependencies

The application functions with a dependency know as Express. Install express with the following command:

npm install express

Deployment of Application

node index.js

Conclusion
Deploying a Node.js app on AWS offers a reliable and scalable hosting solution. With AWS’s powerful infrastructure, handling high traffic is an easy task. Plus, it’s cost-effective and flexible. By following the steps in this guide, you’ll be all set to launch your Node.js app on AWS.

Harnessing Terraform In Deploying a Dating App On AWS

BlacOrpheus — Fri, 08 Nov 2024 16:32:10 +0000

Synopsis
In this blog post, I’ll walk you through the steps to deploy a landing page for a dating app I created on the AWS cloud. Along the way, I’d demonstrate how to leverage Terraform, an in-demand infrastructure as code tool. Additionally, I’ll guide you on how to communicate seamlessly with a GitHub repository. Let’s get started!

Backstory
Terraform is an open-source Infrastructure as Code (IaC) tool created by HashiCorp. It enables users to define and provision infrastructure resources—such as virtual machines, databases, and networks—through declarative configuration files. By automating the setup and configuration of necessary resources on the AWS cloud, Terraform simplifies management, versioning, and replication across various environments. This method provides advantages like repeatability, scalability, and improved collaboration when deploying and managing your dating app on AWS.

Requirements
An AWS Account
VS Code
A GitHub Account

Procedure
Create an AWS access key
The following link will guide you through the process:
Managing Access Keys for IAM Users

After creating the keys, save the details.

Connect your VS Code to your AWS account:
On your VS Code terminal type in the following command:

aws configure

Type in your details from the access key you created when prompted.

Clone your code from GitHub
Here is the link to the repository on my GitHub account:

Ensure you VS Code is connected to your GitHub account, then run the following command in your terminal:

git clone https://github.com/BlacOrpheus/Terraform-Dating-App.git

Run your infrastructure in Terraform
If you do not have Terraform already installed on your local machine, you’d need to install it. If not, visit the official Terraform downloads page and download the appropriate version for your operating system (Windows, macOS, or Linux).

On your command line enter the following:

terraform init

terraform plan

terraform apply

Type “yes” when prompted to deploy the resources or not.

terraform destroy

Conclusion
Terraform provides a robust solution for seamlessly orchestrating cloud resources. By adopting this technology, you can unlock new opportunities for innovation and enable developers to concentrate on creating exceptional applications. Leverage the capabilities of Terraform to elevate your AWS deployments to new heights.

Streamlined CI/CD Pipeline Management with Jenkins: Utilizing Termius and AWS for Flawless Integration

BlacOrpheus — Wed, 16 Oct 2024 20:26:02 +0000

Synopsis

In this project, we delve into the realm of Continuous Integration/Continuous Deployment (CI/CD) pipeline management, focusing on optimizing efficiency and integration through Jenkins, Termius, and AWS services. This comprehensive exploration showcases the power of automation in software development workflows.

We begin by configuring Jenkins, a leading automation server, to orchestrate seamless build, test, and deployment processes. Leveraging its extensive plugin ecosystem, we customize pipelines to meet specific project requirements, ensuring rapid, reliable, and consistent delivery of applications.

To enhance security and accessibility, we introduce Termius as a robust SSH client, establishing secure connections for remote server management. Through Termius, we demonstrate effective command-line interactions, enabling efficient deployment and monitoring tasks.

By the conclusion of this endeavor, participants will have gained a deep understanding of Jenkins, Termius, and AWS integration, empowering them to implement robust CI/CD pipelines that accelerate software delivery while maintaining a high level of security and reliability.

Backstory

Jenkins stands as a cornerstone in modern software development, serving as an indispensable CI/CD (Continuous Integration/Continuous Deployment) tool. Its significance lies in its ability to streamline and automate critical aspects of the development pipeline. Its contribution in enhancing efficiency, quality, and collaboration cannot be overstated. As a foundational tool, Jenkins empowers organizations to deliver high-quality software with speed and confidence, thereby driving innovation and success in the digital landscape.

Requirements

An AWS Account
Termius (SSH platform for Mobile and Desktop)
Basic Understanding of Linux
A GitHub Account
A Jenkins Account

Termius

GitHub

GitHub is a web-based platform designed for version control and collaborative software development. It allows individuals and teams to manage and track changes in code, enabling seamless collaboration on projects. GitHub provides tools for creating repositories (storage spaces for code), branching (creating separate lines of development), and merging (combining code changes). It also offers features like issue tracking, pull requests, and code reviews to facilitate efficient teamwork.

Jenkins

Jenkins is an open-source automation server used for Continuous Integration and Continuous Deployment (CI/CD). It automates various stages of software development, including building, testing, and deploying code changes. Jenkins streamlines collaboration among development teams and enhances the efficiency of software delivery. With a vast library of plugins, Jenkins can be customized to integrate with a wide range of tools and technologies.

Procedure

Anyone can effortlessly reproduce this procedure on their personal computer by carefully following the provided instructions below.

Create an AWS instance and connect it to Termius
In my previous article, I give a detailed approach on how to go about this.
Install Jenkins on you ec2 instance.
Add the key to your system:

sudo wget -O /usr/share/keyrings/jenkins-keyring.asc \ https://pkg.jenkins.io/debian-stable/jenkins.io-2023.key

Add a Jenkins apt repository entry:

echo deb [signed-by=/usr/share/keyrings/jenkins-keyring.asc] \ https://pkg.jenkins.io/debian-stable binary/ | sudo tee \ /etc/apt/sources.list.d/jenkins.list > /dev/null

Update your local package index, then finally install Jenkins:

sudo apt-get update sudo apt-get install fontconfig openjdk-11-jre sudo apt-get install jenkins

To Check the status of the installation:

sudo systemctl status jenkins

Connect to Jenkins

copy your AWS IP address and add a port 8080 to it, which is the default port Jenkins listens on.

18.215.151.231:8080

On your Termius terminal, type in the following to get your Jenkins Password and Login to Jenkins:

sudo cat /var/lib/jenkins/secrets/initialAdminPassword

Create a new job in Jenkins

Choose a name for your project, I titled mine “my-first-jenkins-job”, select “Freestyle project” and click on “OK”.

Edit your Jenkins job

Source Code Management

Input the repository Link and choose “*/master” as the Branch Specifier.

Build Triggers

Select “GitHub hook trigger for GITScm polling”

Build Steps

Select “Execute Shell” and type in the following:

cp -r index.js /var/www/sageapp cp -r index.html /var/www/sageapp

When the build is initiated, the “index.js” and “index.html” files are copied into “/var/www/sageapp” folder.

Click on “Save” and “Apply”.

Add GitHub webhook

Go to your repository on GitHub and click on “Settings”, then click on “Webhooks” , click on “Add webhook” then enter your jenkins IP address followed by “//github-webhook/”, finally click on “Update webhook” and enter you GitHub Password.

Start with the process of continous integration and continous deployment

`--c-brand: #996515;
.text-uppercase{
color: #9F2B68;

}

.shade-of-pink{

color:#F2D2BD

Go back to your Termius Terminal and run the following set of commands

` cd /var/lib/jenkins/workspace

cd my-first-jenkins-job

node index.js `

Go back to the style.css file and edit the file again by changing the following:

` --c-brand: #161748;

.text-uppercase{
color: #c89666;

}

.shade-of-pink{

color:#161748;

} `

refresh your browser:

Conclusion

To put it simply, mastering Efficient CI/CD Pipeline Management with Jenkins, and leveraging the power of Termius and AWS, represents a significant stride forward in modern software development. The seamless integration of these tools not only accelerates the development lifecycle but also ensures security, scalability, and reliability in the deployment process.