DEV Community: Ekemini Thompson

DDSS: Step-by-Step Explanation

Ekemini Thompson — Wed, 07 Jan 2026 17:12:52 +0000

Hey there! This guide is for an assignment (looks like "DDSS 2025 Assignment 2") where you'll set up a simple web app using Docker, Python (with Flask), and PostgreSQL. The goal is to demonstrate common security vulnerabilities like SQL injection and cross-site scripting (XSS), and then show how to fix them.

I'll explain every step in simple terms. We'll go slow, define new words, and I'll tell you why each step matters. You'll need a computer with Docker installed (it's a tool to run apps in "containers" like isolated boxes). If you don't have Docker, download it from the official website (docker.com) and install it.

Important Safety Note: This is for learning only. Don't run vulnerable code on the internet—it's just for your local machine to understand bugs.

Step 1: Download and Unzip the File

The guide says: "Download the file I sent to you and unzip it."
What to do: The file is a ZIP archive (like a compressed folder) named "ddss-2025-assignment2-rc-main-2.zip". Just sent on WhatsApp; save it to your Downloads folder.
How to unzip:
- On Windows: Right-click the ZIP file > Extract All.
- On Mac: Double-click the ZIP file—it unzips automatically.
- On Linux: Open a terminal and run unzip ddss-2025-assignment2-rc-main-2.zip.
Why? This gives you the code files, like Python scripts, a Docker setup file, and the app code.
Result: You'll have a folder called "ddss-2025-assignment2-rc-main-2" (or similar).

Step 2: Start Docker

The guide says: "Start docker."
What to do: Open the Docker app on your computer. It might be called "Docker Desktop." Make sure it's running (look for an icon in your taskbar or menu bar showing a whale).
Why? Docker will create containers for your database (PostgreSQL) and web app, so everything runs without messing up your computer.
Tip: If Docker isn't installed, pause here and install it. Test it by opening a terminal (Command Prompt on Windows, Terminal on Mac/Linux) and typing docker --version. It should show a version number.

Step 3: Go to Your Terminal or Command Prompt

The guide says: "Go to your terminal or cmd."
What to do:
- Windows: Search for "cmd" or "Command Prompt."
- Mac: Search for "Terminal."
- Linux: It's already there—open Terminal.
Why? We'll run commands here to set up and run the app.

Step 4: Navigate to the Folder

The guide says: "cd Downloads" then "cd ddss-2025-assignment2-rc-main-2".
What to do:
- Type cd Downloads and press Enter. (This "changes directory" to your Downloads folder.)
- Then type cd ddss-2025-assignment2-rc-main-2 and press Enter. (Go into the unzipped folder.)
Why? Commands need to run from inside the project folder where the files are.
Tip: If you get an error like "No such file or directory," double-check the folder name (use ls on Mac/Linux or dir on Windows to list files).

Step 5: Install Python Packages

The guide says: "pip install flask psycopg2-binary werkzeug bandit".
What to do: In the terminal, type that exact command and press Enter.
What is this?
- pip is a tool to install Python libraries (like downloading apps for Python).
- Flask: A framework to build web apps in Python.
- psycopg2-binary: Helps Python talk to PostgreSQL databases.
- Werkzeug: Helps with web stuff in Flask.
- Bandit: A tool to check code for security issues (optional here, but good practice).
Why? Your app needs these to run.
Tip: If you don't have Python, install it from python.org (version 3.x). Also, you might need a "virtual environment" for cleanliness, but for now, this is fine.

Step 6: Run the Docker Script

The guide says: "./docker-compose-python-psql.sh".
What to do: In the terminal (still in the project folder), type ./docker-compose-python-psql.sh and press Enter.
What is this? This is a shell script (a file with commands) that uses Docker Compose (a Docker tool) to build and start two containers: one for the Python/Flask app and one for the PostgreSQL database.
Why? It sets up the environment automatically. It might take a few minutes to download and build stuff—be patient!
Tip: If it says "permission denied," run chmod +x docker-compose-python-psql.sh first to make it executable. Watch for "finished building" message.

Step 7: Connect to the Database

The guide says: Open another tab on the same command prompt and paste "docker exec -it db psql -U ddss-database-assignment-2 -d ddss-database-assignment-2". Then "enter".
What to do:
- Open a new terminal tab (or window).
- Paste that command and press Enter.
What is this?
- docker exec: Runs a command inside a running Docker container.
- -it db: Interactive mode in the "db" container (the database one).
- psql: The PostgreSQL command-line tool to interact with the database.
- -U and -d: Username and database name.
Why? This lets you access the database shell to run SQL commands if needed (but the guide doesn't specify more here—maybe for debugging).
Tip: You'll see a prompt like "ddss-database-assignment-2=#". Type \q to exit when done. Then switch back to the first terminal tab.

Step 8: Open the App in Your Browser

The guide says: "Go to your browser and paste http://localhost:8080".
What to do: Open Chrome, Firefox, or any browser. Type or paste http://localhost:8080 in the address bar.
Why? This is the web app's home page running on your local machine (port 8080).
What you'll see: Probably a login page or menu for the assignment parts.

Step 9: Register a User

The guide says: Open another browser tab and go to "http://localhost:8080/register".
What to do: Do that—register with a username and password (real ones, not the exploit yet).
Why? Some parts require being logged in.

Step 10: Test Part 1 - Vulnerable SQL Injection (Login Bypass)

The guide explains testing SQL injection, a bug where bad input tricks the database.
Vulnerable Form:
- Go to the login page (probably at /part1 or similar—check the app).
- Username: ' OR '1'='1' --
- Password: Anything (e.g., "blah").
- Login. It should say "VULNERABLE LOGIN SUCCESS".
Why it works: This input injects SQL code. The query becomes something like SELECT * WHERE username='' OR '1'='1' -- AND password=.... The -- comments out the password check, and '1'='1' is always true, so it logs in without a real username/password.
Why the explanation about precedence? In SQL, AND is stronger than OR, so without --, the password part still blocks it.
Secure Form:
- Try the same username/password.
- It should say "SECURE LOGIN FAILED".
Why? The secure version uses "prepared statements" to prevent injection—inputs are treated as data, not code.

Step 11: Test Part 2 - Session Authorization and More

Not Logged In:
- Try accessing /part2.html and /part3.html.
- Should redirect to /part1.html (login required).
Logged In (Secure Way):
- Login properly via the secure form.
- Then access /part2.html and /part3.html—should work.
Why? Even if vulnerable login lets you in, sessions (like cookies tracking login) prevent accessing protected pages without proper auth.

Step 12: Test Stored XSS in Part 2

XSS is a bug where bad input (like scripts) runs as code in the browser.
Vulnerable Form:
- In the message form (probably at /part2), submit: <script>alert('XSS')</script>.
- Reload the page—an alert popup should appear.
Why? The app stores the script in the DB and displays it without escaping, so the browser runs it as JavaScript.
Secure Form:
- Submit the same: <script>alert('XSS')</script>.
- Reload—no popup. It shows as plain text.
Why? The secure version escapes output (e.g., using Jinja templates in Flask) so < becomes <, making it harmless.
Messages List: The guide shows example messages—yours might vary, but test to see the difference.
Summary Table for Report:
- Copy this into your assignment report: | Version | Vulnerability | Result | |-----------|---------------|-----------------| | Vulnerable| Stored XSS | JS executed | | Secure | Escaped output| Safe display |

Step 13: Core Work Complete

You've now shown SQL injection (for login and possibly data access) and XSS, plus fixes.
This covers "Exercise 1" in the assignment.

Step 14: Test Part 3 - SQL Injection in Queries

Vulnerable Query:
- In the insecure form (look for price more than), enter price: 0 OR 1=1 --.
- Submit—it should list ALL books.
Why? Injection tricks the SQL to ignore the price and return everything (similar to login bypass).
Secure Query:
- Same input—should list NO books or fail safely.
Why? Parameterized queries prevent the injection.

Final Tips for You

Troubleshooting: If something fails, check terminal errors. Restart Docker with docker-compose down then rerun the script.
Learning Points: This teaches why input validation, prepared statements, and output escaping are crucial in web apps.
Report: Take screenshots of successes/failures, explain like I did, and include the table.
Clean Up: When done, stop Docker containers with docker-compose down in the folder.

bandit
Great, this is exactly what Part 2.2 + 2.3 expects.
I’ll guide you step-by-step, in exam/report-ready order, with exact commands, what you should see, and what to write down.

You can literally follow this and tick boxes.

✅ PART 2.2 — Run the Tools

🔹 A. Run Bandit (Static Analysis)

From project root (where app.py exists):

bandit -r app.py

Or entire backend folder:

bandit -r app/

Step 3 — What Bandit should report (EXPECTED)

You should see findings like:

✅ SQL Injection (TRUE POSITIVE)

[B608:hardcoded_sql_expressions] Possible SQL injection vector through string-based query construction.

Triggered by:

query += f" AND price >= {pricemin}"

✔ This is INTENTIONAL (vulnerable route)

✅ Weak Cryptography (if applicable)

[B303:md5] Use of weak cryptographic hash

[B324:hashlib] Use of weak SHA256 for password hashing

✔ Counts as TP if you used SHA256 instead of bcrypt/PBKDF2.

Step 4 — Save Evidence

Take:

Screenshot of Bandit output
Copy Issue ID, Severity, File, Line number

You will reference this in Part 2.3 table.

zap

## 🔹 B. Run **OWASP ZAP (Dynamic Testing)

**

Step 1 — Download & Start ZAP

Download:
👉 https://www.zaproxy.org/download/

Run ZAP Desktop
Choose:

“No, I do not want to persist this session” (simpler)

Step 2 — Configure Browser Proxy

Proxy settings:

Host: localhost
Port: 8080

Do this in:

Firefox → Settings → Network → Proxy
Chrome → System → Open proxy settings

Step 3 — Verify Proxy Works

Visit:

http://localhost:8080

✔ You should see traffic appearing in ZAP “Sites” tree
❌ If not, proxy is wrong

🔹 C. ZAP Automated Scan (Quick Win)

Step 4 — Quick Start Scan

In ZAP:

Open Quick Start
Enter:

   http://localhost:8080

Click Attack

ZAP will:

Spider your app
Passive scan
Active scan (SQLi/XSS)

⏱ Wait 5–10 minutes

Expected ZAP Alerts (IMPORTANT)

You SHOULD see:

✅ SQL Injection (TRUE POSITIVE)

URL: /login-vulnerable or /part3_vulnerable
Payload: ' OR 1=1 --
Evidence: Authentication bypass / all rows returned

✅ XSS (TRUE POSITIVE)

URL: message submission
Payload:

  <script>alert(1)</script>

Evidence: Script execution in response

⚠ CSRF (Possible FALSE POSITIVE)

“Form has no CSRF token”

✔ Allowed as FP depending on assignment scope

Step 5 — Manual Active Scan (Recommended)

In Sites tree
Right-click your app
Select:

   Attack → Active Scan

This improves SQLi detection.

🔹 D. Manual Exploration (IMPORTANT)

Step 6 — Manual Attacks (Through Browser)

While proxy is enabled:

SQL Injection Test

0 OR 1=1 --

Works in vulnerable
Fails in secure ✔

XSS Test

<script>alert("XSS")</script>

Executes in vulnerable
Escaped in secure ✔

ZAP records these.

🔹 E. Manual Undetected Vulnerability (REQUIRED)

Example 1 — Weak Password Hashing

If your app uses:

hashlib.sha256(password)

Explain:

ZAP ❌ misses it (static issue)
Bandit ✅ detects it

✔ Counts as Manual / Undetected by ZAP

Example 2 — Hardcoded `secret_key`

app.secret_key = "secret123"

Explain exploit:

Predictable secret
Session cookie forgery possible

✔ Excellent manual vulnerability

✅ PART 2.3 — Classification Table (REPORT)

Use this table exactly (you can paste it):

Tool	Vulnerability	TP / FP	Reason
ZAP	SQL Injection (login-vuln)	TP	Payload `' OR 1=1 --` bypassed authentication
ZAP	Stored XSS (text-vuln)	TP	Script executed on message display
Bandit	SQL string concatenation	TP	f-strings used in vulnerable queries
ZAP	CSRF (no token)	FP	Forms lack tokens but CSRF not required in assignment
Bandit	Weak crypto (SHA256)	TP	Passwords not hashed with adaptive algorithm

✅ Discussion Points (WRITE THIS)

You can use this verbatim:

OWASP ZAP is effective at identifying runtime vulnerabilities such as SQL injection and XSS, but it may miss implementation-level weaknesses like weak cryptographic choices. Bandit complements ZAP by identifying insecure coding patterns through static analysis but lacks execution context. Some vulnerabilities, such as hardcoded secrets or weak hashing, require manual inspection. The combined use of static and dynamic tools provides significantly better coverage than either tool alone.

🎯 Final Checklist (Tick These)

✔ Bandit run
✔ ZAP automated scan
✔ ZAP active scan
✔ Manual attacks performed
✔ One manual undetected vulnerability
✔ Classification table completed
✔ Discussion written

If anything confuses you, ask for clarification on a specific step! You've got this—CS is all about experimenting. 🚀

ML Serving as a Microservice

Ekemini Thompson — Thu, 11 Sep 2025 09:32:23 +0000

AI-in-the-Loop Healthcare: Engineering Pregnancy Fit-to-Fly

Pregnancy Fit-to-Fly is not just another full-stack app—it’s a production-ready demonstration of how machine learning can be embedded as a first-class system component, orchestrating user experience in real time.

At its essence, the platform automates the issuance of medical fitness-to-fly certificates for pregnant passengers, but beneath the surface it showcases a robust AI/ML architecture engineered for low-latency inference, modular scalability, and safety-critical decisioning.

AI-Driven System Design

Unlike traditional healthcare apps that bolt AI onto the side, this project was built around the principle of AI-in-the-loop workflows. The models are not background advisors—they are the control plane.

The system is composed of three independent but tightly integrated layers:

Frontend (clients/): A tab-based user workflow built on modern JavaScript modules.
API Backend (server/): Node.js/Express service handling authentication, certificate issuance, and integration with doctors and payments.
ML Backend (ml/): A FastAPI-powered inference engine serving lightweight predictive models.

This modular separation ensures that models evolve independently from application logic, enabling rapid iteration and scalable deployment across microservices.

Machine Learning Core

The ML service processes structured health data spanning demographics, physiological measures, behavioral scores, and binary symptoms. Feature vectors are dynamically assembled into a numerical pipeline before inference, ensuring data flexibility and consistency.

The models include:

Heart Rate Predictor (Regression) – fast BPM estimation adjusted for age, activity, and stress.
Blood Pressure Predictor (Regression) – estimates systolic/diastolic levels from feature interactions.
Eligibility Classifier (Binary Classification) – outputs probability of “fit-to-fly,” tuned for conservative, safety-first thresholds.

All models are optimized for sub-100ms inference, containerized for cloud portability, and exposed via stateless API endpoints—making them inherently horizontally scalable under load.

ML Serving as a Microservice

The ML backend operates as a stateless FastAPI microservice, designed around the following principles:

JSON schema contracts → Frontend remains model-agnostic.
Stateless inference → Seamless horizontal scaling via Kubernetes or Swarm.
API-first extensibility → New models or endpoints can be added without breaking downstream integrations.
Safety-first gating → Eligibility decisions halt unsafe workflows at runtime.

This design abstracts away complexity for the frontend, while maintaining the flexibility of plugging in new predictive engines (e.g., gestational risk models, wearable-device streams).

Production-Grade Stack

The technical stack reflects an engineering-for-scale mindset:

ML Backend: Python 3.8+, FastAPI, scikit-learn/XGBoost, NumPy, Pandas
API Backend: Node.js/Express, JWT-based authentication, pluggable data layer (MongoDB/Postgres)
Frontend: Modular ES modules, esbuild for bundling
DevOps: Docker-first, .env-based configuration, ready for cloud CI/CD pipelines

Every layer is decoupled but orchestrated, enabling teams to iterate on AI models, backend services, or frontend workflows independently—without regressions.

Workflow Orchestration

The application flow illustrates real-time AI integration:

Passenger logs in (JWT-authenticated).
Health data collected via form-driven interface.
Features sent to ML API → model inference controls navigation.

If “fit-to-fly” → system unlocks doctor selection.
If not → workflow halts, preventing unsafe certification.
1. Payment handled via external gateway (Paystack).
2. Certificate issued as a secure, verifiable PDF.

Here, model predictions aren’t just insights—they are gatekeepers, dynamically shaping user experience.

Scalability & Reliability

The architecture is microservice-native:

Independent deployments → ML and API can scale separately.
Observability hooks → Request-level logging for monitoring inference performance.
Security → JWT gating ensures only authenticated requests reach the ML backend.
Future extensibility → Designed to incorporate explainability, wearables, or federated updates.

In short, this isn’t a prototype—it’s production-ready AI infrastructure applied to healthcare.

Future AI-Centric Extensions

The roadmap pushes beyond predictive gating into next-gen applied AI systems engineering:

LLM Integration: Natural-language medical explanations (“why eligible/ineligible”).
Edge Deployment: Model exports via ONNX/TensorRT for airline devices or on-prem clinics.
Explainability Layer: SHAP/LIME to expose feature importance in real time.
Federated Learning: Decentralized, privacy-preserving model improvements.
Wearable Integration: Real-time vitals streaming for continuous eligibility tracking.

This trajectory aligns with xAI’s ethos: building real-world AI systems that adapt, explain, and scale.

Why This Project Matters

AI-first architecture – models are core, not add-ons.
Safety-critical deployment – predictions gate life-impacting workflows.
Production engineering – decoupled microservices, containerized, and scalable.
Vision alignment – AI deployed for real human impact in aviation and healthcare.

Pregnancy Fit-to-Fly isn’t just a health app. It’s a blueprint for applied AI systems at scale—a showcase of how machine learning, microservices, and modern deployment pipelines converge into a single mission-critical product.

Building a Multimodal AI Chatbot with Flask, Transformers, and BLIP

Ekemini Thompson — Fri, 01 Aug 2025 19:47:48 +0000

Introduction

In today’s rapidly evolving AI landscape, combining multiple modalities—such as text and images—into a single system offers more intuitive and dynamic user interactions. This article guides you through the process of building a lightweight multimodal chatbot using Flask, Hugging Face Transformers, and BLIP (Bootstrapped Language Image Pretraining).

You can find the complete project here:
👉 GitHub: multimodal-chatbot-app

💡 What is a Multimodal Chatbot?

Unlike traditional chatbots that only handle text, multimodal chatbots process multiple forms of input, such as:

🧾 Natural language queries (text)
🖼️ Image uploads for captioning

This makes the interaction more versatile—for example, a user can ask a science question or upload an image and get a description of what it contains.

🧰 Tech Stack

Here’s a breakdown of the tools and frameworks used:

Feature	Tool/Library
Backend Server	Flask
Language Model	Hugging Face Transformers
Image Captioning	Salesforce BLIP (via Transformers)
ML Framework	PyTorch
Image Handling	Pillow (PIL)

🚀 How It Works

1. Text-Based Q&A

For science-related questions, the chatbot uses a pre-trained DistilBERT model fine-tuned on the SQuAD dataset to generate answers.

Example:

Q: What is the boiling point of water?
A: The boiling point of water is 100°C.

2. Image Captioning

When a user uploads an image, the app uses BLIP (by Salesforce) to generate a human-like description of the image.

Example:

📷 Image: A cat on a bench
🧠 Output: “A cat sitting on a wooden bench outdoors.”

🧪 Installation Guide

⚙️ I recommend using a virtual environment to avoid dependency conflicts.

Clone the repo:

git clone https://github.com/EkeminiThompson/multimodal-chatbot-app.git
cd multimodal-chatbot-app

Set up environment:

python3 -m venv venv
source venv/bin/activate  # macOS/Linux
# .\venv\Scripts\activate  # Windows

Install dependencies:

pip install -r requirements.txt

Run the app:

python multimodal_chatbot.py

Open your browser or Postman and access:
🔗 http://127.0.0.1:5000/chat

🧠 Code Overview

The core logic lives in multimodal_chatbot.py. The /chat endpoint handles both text and image POST requests:

@app.route('/chat', methods=['POST'])
def chat():
    if 'text' in data:
        # handle Q&A
    elif 'image' in request.files:
        # handle image captioning

Both models are loaded during startup using Hugging Face's pipeline() function.

🧪 Testing the Endpoints

🧾 For Text

curl -X POST http://127.0.0.1:5000/chat \
  -H "Content-Type: application/json" \
  -d '{"text": "What is the chemical formula of water?"}'

🖼️ For Image

Use Postman or any frontend tool to send an image as form data (multipart/form-data) with the key image.

🔄 Future Enhancements

Here are some features I’m exploring for future iterations:

🎨 Frontend interface (React, Streamlit, or simple HTML)
🗣️ Voice input using SpeechRecognition
🌐 Deploy to Hugging Face Spaces or Render
🌍 Support for multilingual interaction

📘 Final Thoughts

This project is a great way to experiment with combining multiple AI models to build intelligent systems. Whether you're a developer, researcher, or AI enthusiast, creating a multimodal chatbot offers both a technical challenge and a glimpse into the future of human-computer interaction.

Check out the full code and try it yourself 👉 GitHub Repo

📬 Stay Connected

Let’s connect on:

GitHub: @EkeminiThompson
LinkedIn: linkedin.com/in/ekemini-thompson

If you found this helpful, don’t forget to ⭐️ the repo and share the article!

Deployment of Predictive Maintenance Aircraft Engine System

Ekemini Thompson — Fri, 27 Dec 2024 03:39:58 +0000

The Predictive Maintenance Aircraft Engine system is designed to leverage real-time sensor data from aircraft engines to predict when maintenance is needed, minimizing unplanned downtime and optimizing maintenance schedules. This document provides a detailed overview of the deployment process for the system, covering the full-stack architecture, Docker setup, and steps to deploy the application using Docker and Docker Compose.

System Overview
Architecture Design
Setting Up Docker Containers
- Docker Compose Setup
- Backend and Frontend Dockerfiles
Running the Application
Deployment Considerations
Conclusion

1. System Overview

This system is composed of two key components:

Frontend (Dash): A real-time dashboard built using Dash to visualize predictive maintenance results and sensor data.
Backend (Flask): A Flask-based API that handles model inference, processes incoming sensor data, and exposes endpoints for prediction and analysis.

The backend performs the critical task of predicting the maintenance needs based on historical data and real-time sensor input. The frontend displays this information in a user-friendly format, enabling operators to take timely action and improve operational efficiency.

2. Architecture Design

Backend (Flask)

The backend is a RESTful API implemented using Flask, designed to:

Accept incoming requests with sensor data.
Process this data using machine learning models (e.g., classification or regression) to predict maintenance needs.
Expose endpoints that the frontend can query for real-time predictions and historical analysis.

Frontend (Dash)

The frontend, built with Dash, serves the purpose of:

Displaying real-time predictions, trends, and other data visualizations.
Allowing users to interact with the predictions and monitor engine performance.
Making API calls to the backend for up-to-date information.

Containerization with Docker

To streamline deployment and ensure that the application runs consistently across different environments, both the frontend and backend are containerized using Docker. Docker Compose is used to define and manage the multi-container setup.

3. Setting Up Docker Containers

Docker Compose Setup

The docker-compose.yml file orchestrates the deployment of both frontend and backend services. It defines how to build and link the containers, as well as how they communicate with each other via a custom network. Below is an example docker-compose.yml file that defines the services:

version: '3.8'

services:
  backend:
    build:
      context: .
      dockerfile: backend/Dockerfile
    ports:
      - "5000:5000"
    volumes:
      - ./data:/app/data
    networks:
      - app-network

  frontend:
    build:
      context: .
      dockerfile: frontend/Dockerfile
    ports:
      - "8050:8050"
    depends_on:
      - backend
    networks:
      - app-network

networks:
  app-network:
    driver: bridge

Key elements:

backend service: Runs the Flask API on port 5000 and mounts a data directory for persistent storage.
frontend service: Runs the Dash app on port 8050 and depends on the backend to be ready before starting.
app-network: A custom Docker network that allows the frontend and backend to communicate securely.

Backend Dockerfile (`backend/Dockerfile`)

This Dockerfile builds the container for the backend service, which runs the Flask API. It includes installation of Python dependencies and setting the environment variables needed to run the Flask application.

FROM python:3.9-slim

WORKDIR /app

COPY backend/requirements.txt /app/

RUN pip install --no-cache-dir -r requirements.txt

COPY backend/ /app/

EXPOSE 5000

ENV FLASK_APP=app.py
ENV FLASK_RUN_HOST=0.0.0.0

CMD ["flask", "run"]

Frontend Dockerfile (`frontend/Dockerfile`)

The frontend service is containerized using a similar Dockerfile. This file sets up the Dash app and exposes it on port 8050.

FROM python:3.9-slim

WORKDIR /app

COPY frontend/requirements.txt /app/

RUN pip install --no-cache-dir -r requirements.txt

COPY frontend/ /app/

EXPOSE 8050

CMD ["python", "app.py"]

Key elements:

Both backend and frontend Dockerfiles install the necessary dependencies, copy the application code, expose the respective ports, and start the application servers when the containers are run.

4. Running the Application

Prerequisites

Before deploying the application, ensure that you have the following installed on your machine:

Docker: A tool that enables containerization.
Docker Compose: A tool for defining and running multi-container Docker applications.

Steps to Run the Application

Clone the repository: First, clone the GitHub repository and navigate to the project directory.

   git clone <repository_url>
   cd <project_directory>

Build and start the services: Using Docker Compose, you can build and start both the backend and frontend services simultaneously.

   docker-compose up --build

Access the application:
Once the containers are running, you can access the following services:
- Backend API: http://localhost:5000 This endpoint will accept POST requests with sensor data and return maintenance predictions.
- Frontend (Dash): http://localhost:8050 This is the interactive dashboard that will visualize maintenance predictions, trends, and other insights in real-time.
Stop the services:
When you're done, you can stop the services by pressing Ctrl+C or running:

   docker-compose down

5. Deployment Considerations

While Docker provides a consistent development and testing environment, there are additional considerations for deploying the system in a production environment:

a) Scaling the Application

Docker Compose is suitable for local development and testing, but for production deployments, you may need to use orchestration tools like Kubernetes to handle scaling and resource management. Kubernetes can automatically scale the frontend and backend services based on traffic demands, ensuring high availability and fault tolerance.

b) Monitoring and Logging

To ensure the system is running smoothly in production, integrate monitoring tools like Prometheus and logging systems like ELK stack (Elasticsearch, Logstash, and Kibana). These tools will allow you to track system performance, detect issues in real-time, and troubleshoot effectively.

c) Model Management

The predictive maintenance model deployed in the backend may require periodic updates as new sensor data becomes available. It's essential to:

Monitor model performance to ensure its accuracy.
Retrain the model periodically with new data.
Version models and keep track of model iterations for reproducibility.

d) Security

To secure the communication between the frontend and backend:

Use HTTPS by setting up SSL certificates, especially if you're deploying to a production environment.
Implement API rate limiting and authentication mechanisms (e.g., JWT tokens) to prevent misuse of the API.

e) Continuous Integration and Deployment (CI/CD)

For automated deployments, integrate a CI/CD pipeline using tools like GitHub Actions, Jenkins, or GitLab CI. This pipeline can automatically build, test, and deploy new versions of the application when changes are pushed to the repository.

6. Conclusion

The Predictive Maintenance Aircraft Engine system provides a comprehensive solution for monitoring and predicting maintenance needs in real-time. By combining Flask for the backend API, Dash for interactive visualizations, and Docker for containerization, the system offers a reliable, scalable solution that can be deployed both locally and in production environments.

Following the steps outlined in this document, you can easily deploy the application on your local machine or prepare it for a production environment. With further enhancements, such as scaling, monitoring, and continuous deployment, this solution can serve as a critical tool for optimizing aircraft engine maintenance operations.

Building an Automated Customer Support System with NLP and Machine Learning

Ekemini Thompson — Sat, 17 Aug 2024 14:24:51 +0000

Introduction

In the age of digital transformation, providing efficient and effective customer support is crucial for businesses. Automating customer support using Natural Language Processing (NLP) and machine learning can significantly enhance the customer experience by providing instant responses and resolving common queries without human intervention. This article walks through the steps to build an automated customer support system, leveraging NLP to understand and respond to customer inquiries.

Objectives

Develop an NLP model to understand and process customer queries.
Implement a machine learning algorithm to classify and route inquiries.
Create a user-friendly interface for customers to interact with the support system.
Integrate a feedback loop to continuously improve the system based on user interactions.
Ensure seamless escalation to human agents for complex issues.

Technologies Used

Programming Languages: Python
Frameworks and Libraries: Flask, NLTK, scikit-learn, joblib
Databases: CSV (for simplicity, can be replaced with any DBMS)
APIs: RESTful APIs for integration
Tools: curl, PowerShell, Command Prompt

Step-by-Step Implementation

1. Setting Up the Environment

Begin by installing the necessary Python packages:

# Install Flask
pip install Flask

# Install NLP libraries
pip install nltk

# Install ML libraries
pip install scikit-learn joblib

2. Data Collection and Preprocessing

Assume you have a CSV file (customer_support_data.csv) with columns: query and category. The preprocessing step involves cleaning and preparing the text data.

# data_preprocessing.py
import pandas as pd
import nltk
from sklearn.model_selection import train_test_split

# Download necessary NLTK data
nltk.download('punkt')
nltk.download('wordnet')

# Load the data
data = pd.read_csv('customer_support_data.csv')

# Preprocess the text data
def preprocess_text(text):
    tokens = nltk.word_tokenize(text.lower())
    lemmatizer = nltk.WordNetLemmatizer()
    return ' '.join([lemmatizer.lemmatize(token) for token in tokens])

data['query'] = data['query'].apply(preprocess_text)

# Split the data into training and testing sets
train_data, test_data = train_test_split(data, test_size=0.2, random_state=42)

# Save the preprocessed data
train_data.to_csv('train_data.csv', index=False)
test_data.to_csv('test_data.csv', index=False)

3. Building the NLP Model

Using a TF-IDF vectorizer and a logistic regression model for classification:

# nlp_model.py
import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import make_pipeline
from sklearn.metrics import accuracy_score

# Load the preprocessed data
train_data = pd.read_csv('train_data.csv')
test_data = pd.read_csv('test_data.csv')

# Extract features and labels
X_train, y_train = train_data['query'], train_data['category']
X_test, y_test = test_data['query'], test_data['category']

# Build the NLP model pipeline
model = make_pipeline(TfidfVectorizer(), LogisticRegression())

# Train the model
model.fit(X_train, y_train)

# Evaluate the model
y_pred = model.predict(X_test)
print(f"Accuracy: {accuracy_score(y_test, y_pred):.2f}")

# Save the model
import joblib
joblib.dump(model, 'nlp_model.joblib')

4. Creating the Flask API

Develop a Flask API to handle incoming queries and return the predicted category.

# app.py
from flask import Flask, request, jsonify
import joblib

# Load the trained model
model = joblib.load('nlp_model.joblib')

app = Flask(__name__)

@app.route('/predict', methods=['POST'])
def predict():
    data = request.json
    query = data.get('query')
    if query:
        prediction = model.predict([query])[0]
        return jsonify({'category': prediction})
    return jsonify({'error': 'No query provided'}), 400

if __name__ == '__main__':
    app.run(debug=True)

5. Running and Testing the Flask App

Start the Flask app:

python app.py

Test the endpoint using curl in Command Prompt or Invoke-RestMethod in PowerShell.

Using `Invoke-RestMethod` in PowerShell:

Invoke-RestMethod -Uri http://127.0.0.1:5000/predict -Method Post -ContentType "application/json" -Body '{"query": "How can I reset my password?"}'

Using `curl` in Command Prompt:

curl -X POST http://127.0.0.1:5000/predict -H "Content-Type: application/json" -d "{\"query\": \"How can I reset my password?\"}"

Enhancements and Next Steps

Enhance the NLP Model:
- Experiment with advanced models like BERT or GPT.
- Use comprehensive preprocessing techniques.
Develop the User Interface:
- Create a web or mobile interface using React, Angular, or any framework of your choice.
Integrate with a Backend System:
- Implement user session management and query processing.
- Ensure seamless communication between the frontend and the Flask API.
Implement Feedback Mechanism:
- Allow users to rate the responses.
- Use feedback to retrain and improve the models.
Deployment:
- Containerize the application using Docker.
- Deploy to a cloud platform like AWS, GCP, or Azure.

Conclusion

By following these repository, you can create an automated customer support system that leverages NLP and machine learning to provide efficient and effective customer support. This system not only enhances customer satisfaction but also reduces the workload on human support agents, allowing them to focus on more complex issues. Happy coding!

Building a Real-Time Credit Card Fraud Detection System with FastAPI and Machine Learning

Ekemini Thompson — Mon, 12 Aug 2024 22:00:40 +0000

Introduction

Credit card fraud poses a significant threat to the financial industry, leading to billions of dollars in losses every year. To combat this, machine learning models have been developed to detect and prevent fraudulent transactions in real time. In this article, we'll walk through the process of building a real-time credit card fraud detection system using FastAPI, a modern web framework for Python, and a Random Forest classifier trained on the popular Credit Card Fraud Detection Dataset from Kaggle.

Overview of the Project

The goal of this project is to create a web service that predicts the likelihood of a credit card transaction being fraudulent. The service accepts transaction data, preprocesses it, and returns a prediction along with the probability of fraud. This system is designed to be fast, scalable, and easy to integrate into existing financial systems.

Key Components

Machine Learning Model: A Random Forest classifier trained to distinguish between fraudulent and legitimate transactions.
Data Preprocessing: Standardization of transaction features to ensure the model performs optimally.
API: A RESTful API built with FastAPI to handle prediction requests in real time.

Step 1: Preparing the Dataset

The dataset used in this project is the Credit Card Fraud Detection Dataset from Kaggle, which contains 284,807 transactions, of which only 492 are fraudulent. This class imbalance presents a challenge, but it's addressed by oversampling the minority class.

Data Preprocessing

The features are first standardized using a StandardScaler from scikit-learn. The dataset is then split into training and testing sets. Given the imbalance, the RandomOverSampler technique is applied to balance the classes before training the model.

from sklearn.preprocessing import StandardScaler
from imblearn.over_sampling import RandomOverSampler

# Standardize features
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Balance the dataset
ros = RandomOverSampler(random_state=42)
X_resampled, y_resampled = ros.fit_resample(X_scaled, y)

Step 2: Training the Machine Learning Model

We train a Random Forest classifier, which is well-suited for handling imbalanced datasets and provides robust predictions. The model is trained on the oversampled data, and its performance is evaluated using accuracy, precision, recall, and the AUC-ROC curve.

from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, roc_auc_score

# Train the model
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_resampled, y_resampled)

# Evaluate the model
y_pred = model.predict(X_test_scaled)
print(classification_report(y_test, y_pred))
print("AUC-ROC:", roc_auc_score(y_test, model.predict_proba(X_test_scaled)[:, 1]))

Step 3: Building the FastAPI Application

With the trained model and scaler saved using joblib, we move on to building the FastAPI application. FastAPI is chosen for its speed and ease of use, making it ideal for real-time applications.

Creating the API

The FastAPI application defines a POST endpoint /predict/ that accepts transaction data, processes it, and returns the model's prediction and probability.

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import joblib
import pandas as pd

# Load the trained model and scaler
model = joblib.load("random_forest_model.pkl")
scaler = joblib.load("scaler.pkl")

app = FastAPI()

class Transaction(BaseModel):
    V1: float
    V2: float
    # Include all other features used in your model
    Amount: float

@app.post("/predict/")
def predict(transaction: Transaction):
    try:
        data = pd.DataFrame([transaction.dict()])
        scaled_data = scaler.transform(data)
        prediction = model.predict(scaled_data)
        prediction_proba = model.predict_proba(scaled_data)
        return {"fraud_prediction": int(prediction[0]), "probability": float(prediction_proba[0][1])}
    except Exception as e:
        raise HTTPException(status_code=400, detail=str(e))

Step 4: Deploying the Application

To test the application locally, you can run the FastAPI server using uvicorn and send POST requests to the /predict/ endpoint. The service will process incoming requests, scale the data, and return whether the transaction is fraudulent.

Running the API Locally

uvicorn main:app --reload

You can then test the API using curl or a tool like Postman:

curl -X POST http://127.0.0.1:8000/predict/ \
-H "Content-Type: application/json" \
-d '{"V1": -1.359807134, "V2": -0.072781173, ..., "Amount": 149.62}'

The API will return a JSON object with the fraud prediction and the associated probability.

Conclusion

In this article, we've built a real-time credit card fraud detection system that combines machine learning with a modern web framework. The github link is here. The system is designed to handle real-time transaction data and provide instant predictions, making it a valuable tool for financial institutions looking to combat fraud.

By deploying this model using FastAPI, we ensure that the service is not only fast but also scalable, capable of handling multiple requests concurrently. This project can be further extended with more sophisticated models, improved feature engineering, or integration with a production environment.

Next Steps

To enhance the system further, consider the following:

Model Improvements: Experiment with more advanced models like XGBoost or neural networks.
Feature Engineering: Explore additional features that might improve model accuracy.
Real-World Deployment: Deploy the application on cloud platforms like AWS or GCP for production use.

Harnessing Real-Time Object Detection in the Browser with TensorFlow.js and COCO-SSD

Ekemini Thompson — Thu, 25 Jul 2024 02:56:03 +0000

Introduction

In recent years, the field of machine learning has seen remarkable advancements, particularly in bringing powerful models to web applications. One such breakthrough is the ability to perform real-time object detection directly within a web browser, thanks to technologies like TensorFlow.js and models such as COCO-SSD. This article explores how developers can leverage these tools to create interactive applications that detect objects in live webcam streams, uploaded images, or videos, all without requiring server-side processing.

Understanding TensorFlow.js and COCO-SSD

TensorFlow.js is a JavaScript library developed by Google that allows developers to run machine learning models directly in the browser. It provides a way to deploy pre-trained models or train new ones using JavaScript APIs, making it accessible and easy to integrate with web applications. COCO-SSD (Common Objects in Context - Single Shot MultiBox Detector) is a popular pre-trained model for object detection. It is optimized to detect a wide variety of objects in real-time, making it suitable for interactive applications.

Setting Up the Environment

To begin, developers need to set up their development environment. This typically involves:

Including TensorFlow.js and COCO-SSD in the HTML document using script tags:

  <script src="https://cdn.jsdelivr.net/npm/@tensorflow/tfjs@latest"></script>
  <script src="https://cdn.jsdelivr.net/npm/@tensorflow-models/coco-ssd@latest"></script>

Creating HTML structure to handle user interface elements like video input, image upload, and control buttons.

Building the Application

1. Handling User Input

The application allows users to choose between different input types:

Webcam: Directly captures live video feed from the user's webcam.
Image: Allows users to upload an image file from their device.
Video: Enables users to upload a video file for object detection.

<div id="inputSelection">
    <label><input type="radio" name="inputType" value="webcam" checked> Webcam</label>
    <label><input type="radio" name="inputType" value="image"> Image</label>
    <label><input type="radio" name="inputType" value="video"> Video</label>
</div>
<input type="file" id="imageInput" accept="image/*" style="display:none;">
<input type="file" id="videoInput" accept="video/*" style="display:none;">

2. Displaying Input and Results

The application dynamically displays the selected input (video or image) and detection results using HTML5 elements like <video>, <img>, and <canvas>.

<div id="videoContainer">
    <video id="videoElement" autoplay playsinline></video>
    <div id="infoBox" class="infoBox">
        <p><strong>Detected Object:</strong> <span id="objectLabel"></span></p>
        <p><strong>Confidence:</strong> <span id="confidenceScore"></span></p>
    </div>
</div>
<img id="imageDisplay">
<video id="videoDisplay" controls loop></video>
<canvas id="outputCanvas"></canvas>

3. Implementing Object Detection Logic

JavaScript (script.js) handles the object detection logic using TensorFlow.js and COCO-SSD. This involves:

Initializing the model and loading it asynchronously:

  async function loadModel() {
      const model = await cocoSsd.load();
      return model;
  }

Performing detection on selected input (video or image) and updating the UI with results:

  async function detectObjects(input) {
      const model = await loadModel();
      const predictions = await model.detect(input);
      // Update UI with predictions
  }

Handling different input types (webcam, image, video) and triggering detection based on user actions.

4. User Interaction and Controls

The application includes buttons for controlling object detection:

Start Detection: Initiates object detection based on selected input.
Stop Detection: Pauses or stops the detection process.
Capture Screenshot: Allows users to capture a screenshot of the current detection result.

<div id="controls">
    <button id="startButton">Start Detection</button>
    <button id="stopButton" disabled>Stop Detection</button>
    <button id="captureButton" disabled>Capture Screenshot</button>
</div>

5. Enhancing User Experience

To provide a seamless experience, the application includes a loading indicator (<div id="loadingIndicator">Loading...</div>) to notify users while TensorFlow.js and the COCO-SSD model are being loaded.

Conclusion

In conclusion, TensorFlow.js combined with COCO-SSD opens up exciting possibilities for real-time object detection directly within web browsers. This article has demonstrated the fundamental components and steps involved in building such an application, from setting up the environment to implementing object detection logic and enhancing user interaction. Developers can now leverage these technologies to create interactive and responsive web applications that push the boundaries of what's possible with machine learning on the web. As these technologies continue to evolve, the future looks promising for even more sophisticated and accessible AI-powered web experiences.

Here is the Github Repo

Predictive Maintenance in the Upstream Sector: Implementing Machine Learning with Flask

Ekemini Thompson — Fri, 19 Jul 2024 16:27:43 +0000

In today's fast-paced industrial landscape, predictive maintenance has emerged as a critical strategy to optimize asset management and operational efficiency. This article explores the practical implementation of machine learning techniques within the upstream sector, specifically focusing on a Flask-based application for predictive maintenance.

Introduction

Predictive maintenance leverages historical data and machine learning algorithms to predict equipment failures before they occur, thereby minimizing downtime and operational disruptions. Within the upstream sector of the oil and gas industry, where equipment reliability directly impacts production and safety, predictive maintenance holds significant promise.

Machine Learning Model Selection

Central to our application is the selection and deployment of a RandomForestClassifier, a robust ensemble learning method suitable for both classification tasks and handling complex datasets often encountered in industrial settings.

from sklearn.ensemble import RandomForestClassifier
import joblib

# Initialize the RandomForestClassifier model
model = RandomForestClassifier(n_estimators=100, random_state=42)

# Train the model with your dataset (X_train, y_train)
model.fit(X_train, y_train)

# Save the trained model to a file
joblib.dump(model, 'models/predictive_model.pkl')

Flask Application Setup

Flask provides a flexible and lightweight framework for developing web applications in Python. Our Flask application integrates the trained RandomForestClassifier model to predict equipment health based on sensor data inputs.

Installation and Dependencies

Ensure you have Python and pip installed. Create a virtual environment and install Flask and required libraries:

python -m venv venv
source venv/bin/activate  # Activate virtual environment
pip install Flask scikit-learn joblib pandas

Flask Application Structure

predictive-maintenance-flask/
├── app.py                  # Flask application
├── requirements.txt        # Python dependencies
├── static/
│   └── style.css           # CSS styles
└── templates/
    └── index.html          # HTML template

Flask Application Code

`app.py`

from flask import Flask, render_template, request, jsonify
import joblib
import pandas as pd

app = Flask(__name__)
model = None

# Load the trained machine learning model
def load_model():
    global model
    model = joblib.load('models/predictive_model.pkl')

# Home route
@app.route('/')
def home():
    return render_template('index.html')

# Endpoint to receive sensor data and make predictions
@app.route('/predict', methods=['POST'])
def predict():
    if model is None:
        load_model()  # Load the model if not already loaded

    # Get data from the POST request
    data = request.form.to_dict()

    # Convert the data into a DataFrame
    input_data = pd.DataFrame([data])

    # Make predictions
    prediction = model.predict(input_data)
    prediction_prob = model.predict_proba(input_data)[:, 1]  # Probability of failure

    # Prepare response
    if prediction[0] == 1:
        result = "Equipment failure predicted."
    else:
        result = "Equipment functioning normally."

    output = {
        "prediction": result,
        "probability": float(prediction_prob[0])
    }

    return jsonify(output)

if __name__ == '__main__':
    app.run(debug=True)

Usage and Deployment

Data Input and Prediction:
- Users input sensor data (e.g., temperature, pressure) via a web form.
- The Flask application utilizes the trained model to predict equipment health status (failure or normal) and provides a probability score.
Integration and Scalability:
- Flask's modular architecture allows easy integration with other frameworks and scalable deployment options.
- Enhance the application with real-time data streaming and advanced visualization tools to further optimize predictive maintenance strategies.

Conclusion

By harnessing machine learning and deploying it through Flask, organizations in the upstream sector can achieve proactive maintenance strategies that enhance operational efficiency, minimize downtime, and ensure sustainable production levels. As technology continues to evolve, the application of predictive maintenance will play an increasingly crucial role in maintaining competitiveness and sustainability in industrial operations.

Github link here

Integrated Traffic Management System with Predictive Modeling and Visualization

Ekemini Thompson — Wed, 17 Jul 2024 04:22:09 +0000

Overview

The Traffic Management System (TMS) presented here integrates predictive modeling and real-time visualization to facilitate efficient traffic control and incident management. Developed using Python and Tkinter for the graphical interface, this system leverages machine learning algorithms to forecast traffic volume based on weather conditions and rush hour dynamics. The application visualizes historical and predicted traffic data through interactive graphs, providing insights crucial for decision-making in urban traffic management.

Key Features

Traffic Prediction: Utilizes machine learning models (Linear Regression and Random Forest) to predict traffic volume based on temperature, precipitation, and rush hour indicators.
Graphical Visualization: Displays historical traffic trends alongside predicted volumes on interactive graphs, enhancing understanding and monitoring capabilities.
Real-time Traffic Simulation: Simulates traffic light changes to replicate real-world scenarios, aiding in assessing system responses under various conditions.
Incident Reporting: Allows users to report incidents, capturing location and description for prompt management and response.

Getting Started

Prerequisites

Ensure Python 3.x is installed. Install dependencies using pip:

pip install pandas matplotlib scikit-learn

Installation

Clone the repository:

   git clone <https://github.com/EkeminiThompson/traffic_management_system.git>
   cd traffic-management-system

Install dependencies:

   pip install -r requirements.txt

Run the application:

   python main.py

Usage

Traffic Prediction:
- Select a location, date, and model (Linear Regression or Random Forest).
- Click "Predict Traffic" to see the predicted traffic volume.
- Clear the graph using "Clear Graph" button.
Graphical Visualization:
- The graph shows historical traffic data and predicted volumes for the selected date.
- Red dashed line indicates the prediction date, and green dot shows the predicted traffic volume.
Traffic Light Control:
- Simulates changing traffic light colors (Red, Green, Yellow) to assess traffic flow dynamics.
Incident Reporting:
- Report traffic incidents by entering location and description.
- Click "Report Incident" to submit the report.

Code Overview

`main.py`

# Main application using Tkinter for GUI

import tkinter as tk
from tkinter import messagebox, ttk
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
import random
from datetime import datetime
from sklearn.linear_model import LinearRegression
from sklearn.ensemble import RandomForestRegressor

# Mock data for demonstration
data = {
    'temperature': [25, 28, 30, 22, 20],
    'precipitation': [0, 0, 0.2, 0.5, 0],
    'hour': [8, 9, 10, 17, 18],
    'traffic_volume': [100, 200, 400, 300, 250]
}
df = pd.DataFrame(data)

# Feature engineering
df['is_rush_hour'] = df['hour'].apply(lambda x: 1 if (x >= 7 and x <= 9) or (x >= 16 and x <= 18) else 0)

# Model training
X = df[['temperature', 'precipitation', 'is_rush_hour']]
y = df['traffic_volume']

# Create models
linear_model = LinearRegression()
linear_model.fit(X, y)

forest_model = RandomForestRegressor(n_estimators=100, random_state=42)
forest_model.fit(X, y)

class TrafficManagementApp:
    def __init__(self, root):
        # Initialization of GUI
        # ...

    def on_submit(self):
        # Handling traffic prediction submission
        # ...

    def update_graph(self, location, date_str, prediction):
        # Updating graph with historical and predicted traffic data
        # ...

    # Other methods for GUI components and functionality

if __name__ == "__main__":
    root = tk.Tk()
    app = TrafficManagementApp(root)
    root.mainloop()

Conclusion

The Traffic Management System is a sophisticated tool for urban planners and traffic controllers, combining advanced predictive analytics with intuitive graphical interfaces. By forecasting traffic patterns and visualizing data trends, the system enhances decision-making capabilities and facilitates proactive management of traffic resources. Its user-friendly design ensures accessibility and practicality, making it a valuable asset in modern urban infrastructure management.

Deploying a Static Website on AWS EC2 with NGINX

Ekemini Thompson — Sat, 06 Jul 2024 03:02:11 +0000

In today’s digital age, having a personal or professional website is almost essential. Whether you’re a budding DevOps engineer, a web developer, or a business owner, knowing how to deploy a website is a crucial skill. This guide will take you through deploying a static website on an AWS EC2 instance using NGINX. By the end of this article, you’ll have your website live and accessible to the world.

Prerequisites

Before we dive in, make sure you have the following:

An AWS account
Basic understanding of AWS EC2, SSH, and NGINX
Your static website files ready (HTML, CSS, JavaScript)

Step 1: Launch an EC2 Instance

First, we need to launch an EC2 instance on AWS.

Login to AWS Management Console:
Navigate to the EC2 dashboard and click on "Launch Instance."
Configure Instance:
- Choose an Amazon Machine Image (AMI). We will use the Amazon Linux 2 AMI for this guide.
- Select an instance type (t2.micro is suitable for our needs).
- Configure the instance details, and add storage if necessary.
- Add a tag (optional, but recommended for organization).
- Configure the security group to allow SSH (port 22) and HTTP (port 80) traffic.
Launch Instance:
- Review your settings and launch the instance.
- Download the private key (.pem) file, which you will need to access your instance via SSH.

Step 2: Connect to Your EC2 Instance

With your instance running, the next step is to connect to it using SSH.

Open a terminal and navigate to the directory containing your private key file:

   cd path_to_your_pem_file

Connect to the instance:

   ssh -i "MyProfile.pem" ec2-user@your-ec2-public-ip

Step 3: Install NGINX

Now that you're connected to your instance, it's time to install NGINX, the web server that will serve your static website.

Update the package index:

   sudo yum update -y

Install NGINX:

   sudo amazon-linux-extras install nginx1.12

Start and enable NGINX:

   sudo systemctl start nginx
   sudo systemctl enable nginx

Step 4: Transfer Your Static Website Files

Next, you need to transfer your website files to the EC2 instance.

Use SCP (Secure Copy Protocol) to transfer your files:

   scp -i "MyProfile.pem" -r /path_to_your_website_files/* ec2-user@your-ec2-public-ip:/home/ec2-user

Move the files to the NGINX root directory:

   sudo mv /home/ec2-user/* /usr/share/nginx/html/

Step 5: Configure NGINX

To ensure that NGINX serves your website correctly, we need to adjust its configuration.

Edit the NGINX configuration file:

   sudo nano /etc/nginx/nginx.conf

Update the server block to point to your website files:

   server {
       listen 80;
       server_name your-ec2-public-ip;

       location / {
           root /usr/share/nginx/html;
           index index.html index.htm;
       }
   }

Test the configuration and restart NGINX:

   sudo nginx -t
   sudo systemctl restart nginx

Step 6: Access Your Website

Finally, open your web browser and enter your EC2 instance’s public IP address. Your static website should now be accessible via HTTP on port 80.

Example Files

Here's a glimpse of the files used in this deployment:

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Ekemini Thompson - DevOps Engineer</title>
    <link rel="stylesheet" href="style.css">
</head>
<body>
    <header>
        <div class="header-content">
            <h1>Ekemini Thompson</h1>
            <p>DevOps Engineer HNG Intern <a href="https://hng.tech">https://hng.tech</a></p>
            <nav>
                <a href="#about">About</a>
                <a href="#skills">Skills</a>
                <a href="#projects">Projects</a>
                <a href="#contact">Contact</a>
            </nav>
        </div>
    </header>
    <!-- Other sections -->
</body>
</html>

style.css

body {
    font-family: 'Arial', sans-serif;
    background-color: #f0f0f0;
    color: #333;
    margin: 0;
    padding: 0;
    scroll-behavior: smooth;
}
header {
    background-color: #1a1a1a;
    padding: 20px;
    text-align: center;
    color: #fff;
}
nav a {
    color: #fff;
    text-decoration: none;
    font-weight: bold;
}
nav a:hover, nav a.active {
    color: #00ADB5;
}

Conclusion

Congratulations! You successfully deployed a static website on an AWS EC2 instance using NGINX. This setup ensures that your website is accessible via a public IP address on port 80, providing a reliable and scalable solution for hosting static content.

For more details or to explore further enhancements, visit the HNG Internship website or my github

Deploying your website can seem daunting at first, but it becomes a manageable and rewarding process with the right steps. Happy deploying!

Automating User Management on Ubuntu with Bash Scripting

Ekemini Thompson — Thu, 04 Jul 2024 04:20:56 +0000

In modern IT operations, efficient user management on Linux systems is pivotal for maintaining security and operational flow. Automating tasks such as user creation, group management, and password handling not only saves time but also enhances consistency and reduces errors. This article delves into how to achieve these automation goals using a Bash script (create_users.sh) specifically tailored for Ubuntu environments.

Script Overview
The create_users.sh script simplifies the complex task of managing user accounts through automation. It reads from an input file (user_list.txt), where each line specifies a username followed by associated groups. Upon execution, the script creates users, assigns them to specified groups, sets up their home directories with proper permissions, generates secure passwords, and logs all activities for accountability.

Key Implementation Steps
Input Parsing: The script efficiently parses input to extract usernames and their respective groups, disregarding unnecessary whitespace for cleaner processing.

User and Group Management: For each user entry:

Checks for existing users and creates new ones as needed.
Ensures groups are created if they do not already exist, then assigns users accordingly using administrative commands (useradd, groupadd, usermod).
Home Directory Setup: Post user creation, the script configures home directories under /home/username, ensuring appropriate permissions (chmod) and ownership (chown) are set for security and accessibility.

Password Security: Passwords are randomly generated using cryptographic standards (/dev/urandom) and securely stored in /var/secure/user_passwords.csv. This file restricts access to only authorized users, maintaining confidentiality.

Logging: All script actions, from user creation to password generation, are logged meticulously in /var/log/user_management.log. This log serves as a comprehensive audit trail, aiding troubleshooting and compliance efforts.

Deployment Guide
To deploy the create_users.sh script:

Clone the repository and navigate to the script directory.
Prepare the user_list.txt file with usernames and their respective groups.
Execute the script with root privileges (sudo bash create_users.sh user_list.txt).
Review logs in /var/log/user_management.log and access passwords securely stored in /var/secure/user_passwords.csv as needed.

Detailed Script Overview

The create_users.sh script simplifies the complex task of managing user accounts through automation. It reads from an input file (user_list.txt), where each line specifies a username followed by associated groups. Upon execution, the script creates users, assigns them to specified groups, sets up their home directories with proper permissions, generates secure passwords, and logs all activities for accountability.

Key Implementation Steps

Input Parsing: The script efficiently parses input to extract usernames and their respective groups, disregarding unnecessary whitespace for cleaner processing.

#!/bin/bash

LOGFILE="/var/log/user_management.log"
PASSWORD_FILE="/var/secure/user_passwords.csv"

if [ "$EUID" -ne 0 ]; then
    echo "Please run as root"
    exit 1
fi

if [ ! -f "$1" ]; then
    echo "Input file not found!"
    exit 1
fi

mkdir -p /var/secure
touch "$PASSWORD_FILE"
chmod 600 "$PASSWORD_FILE"

while IFS=';' read -r username groups; do
    username=$(echo "$username" | xargs)
    groups=$(echo "$groups" | xargs)

User and Group Management: For each user entry:

Checks for existing users and creates new ones as needed.
Ensures groups are created if they do not already exist, then assigns users accordingly using administrative commands (useradd, groupadd, usermod).

    if id "$username" &>/dev/null; then
        echo "User $username already exists." | tee -a "$LOGFILE"
    else
        useradd -m "$username"
        echo "User $username created successfully." | tee -a "$LOGFILE"
    fi

    user_group="$username"
    if ! getent group "$user_group" &>/dev/null; then
        groupadd "$user_group"
        echo "Group $user_group created successfully." | tee -a "$LOGFILE"
    fi

    usermod -aG "$user_group" "$username"

    IFS=',' read -ra ADDR <<< "$groups"
    for group in "${ADDR[@]}"; do
        group=$(echo "$group" | xargs)
        if ! getent group "$group" &>/dev/null; then
            groupadd "$group"
            echo "Group $group created successfully." | tee -a "$LOGFILE"
        fi
        usermod -aG "$group" "$username"
        echo "Added $username to group $group." | tee -a "$LOGFILE"
    done

Home Directory Setup: Post user creation, the script configures home directories under /home/username, ensuring appropriate permissions (chmod) and ownership (chown) are set for security and accessibility.

    home_dir="/home/$username"
    if [ -d "$home_dir" ]; then
        chown "$username:$user_group" "$home_dir"
        chmod 755 "$home_dir"
        echo "Home directory $home_dir set up for $username." | tee -a "$LOGFILE"
    fi

Password Security: Passwords are randomly generated using cryptographic standards (/dev/urandom) and securely stored in /var/secure/user_passwords.csv. This file restricts access to only authorized users, maintaining confidentiality.

    password=$(tr -dc A-Za-z0-9 </dev/urandom | head -c 12)
    echo "$username:$password" | chpasswd
    echo "$username,$password" >> "$PASSWORD_FILE"
    echo "Password set for $username." | tee -a "$LOGFILE"

Logging: All script actions, from user creation to password generation, are logged meticulously in /var/log/user_management.log. This log serves as a comprehensive audit trail, aiding troubleshooting and compliance efforts.
```
done < "$1"

echo "User creation process completed." | tee -a "$LOGFILE"
```

Deployment Guide

Prerequisites

Ubuntu environment with Bash shell.
Root or sudo privileges to execute administrative commands (useradd, groupadd, chmod, chown).

Steps to Deploy

Clone the Repository:

   git clone https://github.com/EkeminiThompson/user_automation
   cd create_users

Prepare Input File (user_list.txt):
Create a text file with usernames and their respective groups in the format specified.
Run the Script:
Execute the script with root privileges:

   sudo bash create_users.sh user_list.txt

Review Logs and Passwords:
- View detailed logs in /var/log/user_management.log to verify script execution.
- Access generated passwords securely stored in /var/secure/user_passwords.csv as needed.

Conclusion
By automating user management tasks with create_users.sh, organizations can streamline operations, enhance security, and ensure consistency across Linux environments. This script exemplifies best practices in IT administration, empowering sysadmins to focus on strategic initiatives while maintaining robust user access controls.

Resources
GitHub Repository: Access the script and related files.
HNG Internship: Learn more about opportunities in tech and automation.
HNG Premium: Additional resources for professional growth and development.

About the Author
Ekemini Thompson is a seasoned Linux system administrator passionate about leveraging automation to optimize IT operations.

DEV Community: Ekemini Thompson

DDSS: Step-by-Step Explanation

Step 1: Download and Unzip the File

Step 2: Start Docker

Step 3: Go to Your Terminal or Command Prompt

Step 4: Navigate to the Folder

Step 5: Install Python Packages

Step 6: Run the Docker Script

Step 7: Connect to the Database

Step 8: Open the App in Your Browser

Step 9: Register a User

Step 10: Test Part 1 - Vulnerable SQL Injection (Login Bypass)

Step 11: Test Part 2 - Session Authorization and More

Step 12: Test Stored XSS in Part 2

Step 13: Core Work Complete

Step 14: Test Part 3 - SQL Injection in Queries

Final Tips for You

✅ PART 2.2 — Run the Tools

🔹 A. Run Bandit (Static Analysis)

Step 3 — What Bandit should report (EXPECTED)

✅ SQL Injection (TRUE POSITIVE)

✅ Weak Cryptography (if applicable)

Step 4 — Save Evidence

**

Step 1 — Download & Start ZAP

Step 2 — Configure Browser Proxy

Proxy settings:

Step 3 — Verify Proxy Works

🔹 C. ZAP Automated Scan (Quick Win)

Step 4 — Quick Start Scan

Expected ZAP Alerts (IMPORTANT)

✅ SQL Injection (TRUE POSITIVE)

✅ XSS (TRUE POSITIVE)

⚠ CSRF (Possible FALSE POSITIVE)

Step 5 — Manual Active Scan (Recommended)

🔹 D. Manual Exploration (IMPORTANT)

Step 6 — Manual Attacks (Through Browser)

SQL Injection Test

XSS Test

🔹 E. Manual Undetected Vulnerability (REQUIRED)

Example 1 — Weak Password Hashing

Example 2 — Hardcoded secret_key

✅ PART 2.3 — Classification Table (REPORT)

✅ Discussion Points (WRITE THIS)

🎯 Final Checklist (Tick These)

ML Serving as a Microservice

AI-in-the-Loop Healthcare: Engineering Pregnancy Fit-to-Fly

AI-Driven System Design

Machine Learning Core

ML Serving as a Microservice

Production-Grade Stack

Workflow Orchestration

Scalability & Reliability

Future AI-Centric Extensions

Why This Project Matters

Building a Multimodal AI Chatbot with Flask, Transformers, and BLIP

Introduction

💡 What is a Multimodal Chatbot?

🧰 Tech Stack

🚀 How It Works

1. Text-Based Q&A

2. Image Captioning

🧪 Installation Guide

🧠 Code Overview

🧪 Testing the Endpoints

🧾 For Text

🖼️ For Image

🔄 Future Enhancements

📘 Final Thoughts

📬 Stay Connected

Deployment of Predictive Maintenance Aircraft Engine System

Table of Contents

1. System Overview

2. Architecture Design

Backend (Flask)

Frontend (Dash)

Containerization with Docker

3. Setting Up Docker Containers

Docker Compose Setup

Backend Dockerfile (backend/Dockerfile)

Example 2 — Hardcoded `secret_key`

Backend Dockerfile (`backend/Dockerfile`)

Frontend Dockerfile (`frontend/Dockerfile`)

Using `Invoke-RestMethod` in PowerShell:

Using `curl` in Command Prompt:

`app.py`

`main.py`