I recently participated in a hands-on Cloud Computing Workshop where I explored the practical process of deploying a simple portfolio website using AWS and Docker.
The workshop covered multiple stages of cloud deployment, starting from a basic index.html file and progressing to Docker image creation, containerization, image pulling, container deployment, and website hosting.
This practical experience helped me understand how applications can be packaged into containers and deployed in a cloud environment.
🎯 Objective
The main objective of the workshop was to understand the complete workflow of deploying a simple web application using cloud and container technologies.
The major concepts covered were:
- Creating a basic portfolio using
index.html - Creating a Dockerfile
- Building a Docker image
- Running an image as a Docker container
- Pulling an existing Docker image
- Creating a new container from the pulled image
- Hosting the website through the container
- Understanding AWS S3 and CloudFront
- Understanding the relationship between images, containers, and cloud deployment
🌐 Creating the Portfolio
The project started with a simple portfolio website using a basic index.html file.
The portfolio contained basic information such as:
- Personal introduction
- Education
- Technical skills
- Projects
- Contact information
The initial structure was kept simple so that the focus could remain on understanding containerization and deployment.
🐳 Introduction to Docker
The next stage involved using Docker to containerize the website.
Docker allows an application and its required environment to be packaged into a portable unit called a container.
The basic concept is:
Website Files
↓
Dockerfile
↓
Docker Image
↓
Docker Container
↓
Hosted Website
This helped me understand the difference between a Docker image and a Docker container.
Docker Image
A Docker image is a packaged template containing the application and everything required to run it.
Docker Container
A container is a running instance created from a Docker image.
In simple terms:
Image = Template
Container = Running instance of the template
📝 Creating the Dockerfile
To containerize the portfolio, a Dockerfile was created to define how the website should be packaged and served.
A simple example is:
FROM nginx:latest
COPY index.html /usr/share/nginx/html/index.html
EXPOSE 80
This uses an Nginx image as the base and places the portfolio's index.html file in the appropriate web-server directory.
🏗️ Creating the Docker Image
After creating the Dockerfile, the next step was to build the Docker image.
The workflow was:
index.html
+
Dockerfile
↓
Docker Build
↓
Docker Image
The image contains the required environment and website files needed to run the portfolio.
This was my first practical experience with the process of converting application files into a reusable Docker image.
📦 Creating the Container
Once the image was created, a container was started from that image.
The workflow became:
Docker Image
↓
Create / Run
↓
Docker Container
↓
Nginx Web Server
↓
Portfolio Website
The container provided an isolated environment in which the website could run.
The website could then be accessed through the exposed port.
📥 Pulling a Docker Image
Another important part of the workshop was understanding how Docker images can be pulled from a container registry.
Instead of creating every image from scratch, an existing image can be pulled and used as the foundation for a new container.
The workflow was:
Docker Registry
↓
Pull Image
↓
Local Docker
↓
Create Container
↓
Run Website
This helped me understand the concept of image reuse and container deployment.
🔄 Creating a New Container from a Pulled Image
After pulling the image, a new container was created using that image.
The process demonstrated that the same image can be used to create multiple containers.
Docker Image
|
┌─────────┴─────────┐
↓ ↓
Container 1 Container 2
↓ ↓
Website Website
This is one of the useful features of containerization because applications can be deployed consistently using the same image.
🌐 Hosting the Website
After the container was created and the web server was running, the website was hosted through the container.
The overall process was:
index.html
↓
Dockerfile
↓
Docker Image
↓
Docker Container
↓
Nginx Server
↓
Port Mapping
↓
🌐 Web Browser
This gave me practical experience in hosting a website inside a Docker container.
☁️ AWS Integration
The workshop also introduced the use of AWS services for cloud-based deployment.
I explored Amazon S3 for storing website files and Amazon CloudFront for content delivery.
The overall cloud architecture can be represented as:
User
|
↓
CloudFront CDN
|
↓
AWS / Cloud
|
┌──────┴──────┐
↓ ↓
S3 Docker
Website Files Container
|
↓
Nginx
|
↓
index.html
This helped me understand that cloud deployment can involve multiple technologies working together.
🔧 Complete Workflow
The complete learning workflow from the workshop can be summarized as:
Create index.html
↓
Create Dockerfile
↓
Build Docker Image
↓
Create Docker Container
↓
Run Website
↓
Pull Docker Image
↓
Create New Container
↓
Host Website
↓
Access Through Browser
↓
Explore AWS S3 & CloudFront
💡 Key Learning
The most valuable part of this workshop was understanding the complete relationship between Docker images and containers.
I learned that:
- A Dockerfile defines how an image is built.
- A Docker image is a reusable package.
- A container is created from an image.
- The same image can be used to create multiple containers.
- Images can be pulled from a registry.
- Containers can be used to run web applications.
- Port mapping allows the application inside a container to be accessed externally.
- AWS services can be used as part of a cloud deployment architecture.
🚀 Why Containerization?
Containerization provides a consistent environment for applications.
Instead of installing and configuring the web server directly on every machine, the required environment can be packaged into an image.
This makes the application easier to:
- Deploy
- Move between environments
- Reproduce
- Scale
- Maintain
- Share
For a simple portfolio, this may seem like a small implementation, but the same concepts are widely used for deploying larger applications.
📚 My Takeaway
This workshop gave me practical exposure to both cloud computing and containerization.
Starting with a simple index.html file, I went through the process of:
Creating → Building → Containerizing → Pulling → Running → Hosting
Understanding this workflow helped me connect theoretical concepts with an actual deployment process.
It was a valuable learning experience and gave me a stronger foundation in Docker, AWS, containerization, static website hosting, and cloud deployment.
🎓 Conclusion
The workshop demonstrated how a simple website can be transformed into a deployable containerized application.
Starting with a basic HTML portfolio, I created a Docker image, ran it as a container, explored pulling images, created a new container, and hosted the website.
Along with learning about Amazon S3 and CloudFront, this experience helped me understand the fundamentals of modern cloud and container-based deployment.
This is an important step in my learning journey toward Cloud Computing, DevOps, Docker, AWS, and Cloud-Native technologies. ☁️🐳🚀
Top comments (0)