Lab8

.github/workflows/CI.yml

@@ -0,0 +1,70 @@
+name: CI Pipeline
+
+on: push
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v4
+        with:
+          python-version: "3.11"
+      - name: Install Dependencies
+        working-directory: app_python
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+      - name: Lint Code
+        working-directory: app_python
+        run: flake8 .
+
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v4
+        with:
+          python-version: "3.11"
+      - name: Install Dependencies
+        working-directory: app_python
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+      - name: Run Tests
+        working-directory: app_python
+        run: pytest
+
+  snyk:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: "3.11"
+      - name: Install Snyk CLI
+        run: |
+          npm install -g snyk
+      - name: Run Snyk Vulnerability Test
+        env:
+          SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }} 
+        run: snyk test --all-projects 
+
+  docker:
+    needs: [lint, test, snyk]  
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Build and Push Docker Image
+        uses: docker/build-push-action@v6
+        with:
+          context: app_python
+          push: true
+          tags: ${{ secrets.DOCKER_USERNAME }}/my-fastapi-app:latest

app_python/.dockerignore

@@ -0,0 +1,2 @@
+__pycache__/
+*.pyc

app_python/.gitignore

@@ -0,0 +1,3 @@
+*.pyc
+__pycache__/
+.pytest_cache/

app_python/CI.md

@@ -0,0 +1,13 @@
+# CI Pipeline Best Practices
+
+- **Job Separation**: Divided pipeline into linting, testing, security scanning, and Docker build jobs for clarity and maintainability.
+
+- **`working-directory` Usage**: Ensures tasks run in the correct directory (`app_python`).
+
+- **Efficient Dependency Management**: Installs dependencies from `requirements.txt` and upgrades `pip`.
+
+- **Parallel Job Execution**: Runs linting, testing, and security scanning in parallel to speed up the pipeline.
+
+- **Security with Snyk**: Uses **Snyk** for vulnerability scanning, with API token stored in GitHub Secrets.
+
+- **Docker Integration**: Secures Docker Hub login and only builds and pushes Docker image after passing jobs.

app_python/DOCKER.md

@@ -0,0 +1,20 @@
+# Docker Best Practices
+
+## Security
+
+- The application **does not run as root**, ensuring better security.
+- A dedicated **non-root user** (`appuser`) is created to execute the app.
+
+## Efficiency
+
+- **Using a minimal base image (`python:3.10-slim`)** to keep the image lightweight.
+- **Avoiding unnecessary layers**: Commands are ordered logically to leverage Docker layer caching.
+- **Using `.dockerignore`** to exclude unnecessary files (cache).
+
+## Maintainability
+
+- The `CMD` statement starts the FastAPI application using **Uvicorn**, keeping it lightweight.
+- Dependencies are installed using `pip --no-cache-dir` to **avoid unnecessary bloat**.
+- The FastAPI app files are **copied with ownership (`COPY --chown`)** to prevent permission issues.
+
+---

app_python/Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.10-slim
+
+ENV PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1 \
+    PIP_DISABLE_PIP_VERSION_CHECK=1
+
+RUN groupadd -r appgroup && useradd -r -g appgroup appuser
+WORKDIR /app
+COPY --chown=appuser:appgroup requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY --chown=appuser:appgroup main.py .
+COPY --chown=appuser:appgroup templates/ templates/
+
+USER appuser
+
+EXPOSE 8000
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

app_python/PYTHON.md

@@ -0,0 +1,31 @@
+# Develop and Test Python Web Application
+
+## Choosing a Framework
+
+For this application, **FastAPI** was chosen due to its:
+
+- **High performance** (asynchronous support with `uvicorn`)
+- **Built-in support for type hints** and automatic API documentation
+- **Ease of development and maintainability**
+
+## Best Practices Applied
+
+- **Separation of Concerns:** HTML templates are separate from Python logic using Jinja2.
+
+- **Code Readability:** Good function names and code structure.
+- **Modular Design:** Using FastAPI and template rendering makes the project scalable.
+
+## Python Unit Tests
+
+### Best Practices
+
+- Naming of the tests describe the intent of the test clearly
+- Testing only one concern with each testing fucntion
+- Using the AAA pattern (Arange, Act, Assert)
+
+### Unit Test Overview
+
+The function `get_moscow_time()` is tested to verify:
+
+- Correct dictionary structure.
+- Valid time values.

app_python/README.md

@@ -0,0 +1,84 @@
+[![CI Pipeline](https://github.com/KaramKhaddour/S25-core-course-labs/actions/workflows/CI.yml/badge.svg)](https://github.com/KaramKhaddour/S25-core-course-labs/actions/workflows/CI.yml)
+
+# Moscow Time Display Application (FastAPI)
+
+## Overview
+
+This application is built using FastAPI and provides the current time in Moscow. It is lightweight and fast.
+
+## Prerequisites
+
+Ensure you have Python installed on your system. This application requires Python 3.7 or later.
+
+## Installation
+
+1. Clone the repository :
+
+   ```sh
+   git clone https://github.com/KaramKhaddour/S25-core-course-labs.git
+   cd S25-CORE-CORSE-LABS/app_python
+   ```
+
+2. Install the required dependencies:
+
+   ```sh
+   pip install -r requirements.txt
+   ```
+
+## Running the Application
+
+To start the FastAPI server, run the following command:
+
+```sh
+uvicorn main:app --reload
+```
+
+This will start the development server and enable automatic reloading for changes in the source code.
+
+## Accessing the API
+
+Once the application is running, you can access it via:
+
+- **API Endpoint:** `http://127.0.0.1:8000` (or another specified host/port)
+- **Interactive API Documentation:**
+  - Swagger UI: `http://127.0.0.1:8000/docs`
+
+## Docker Instructions
+
+This application can be built and run as a Docker container.
+
+### Build the Docker Image
+
+To build the Docker image, run:
+
+```bash
+docker build -t my-fastapi-app .
+```
+
+### Run the Docker Container
+
+To run the container:
+
+```bash
+docker run -d -p 8000:8000 my-fastapi-app
+```
+
+### Pull the Docker Image
+
+If you have pushed your Docker image to Docker Hub, pull it using:
+
+```bash
+docker pull karamkhaddourpro/my-fastapi-app
+```
+
+### Running the Pulled Image
+
+```bash
+docker run -d -p 8000:8000 karamkhaddourpro/my-fastapi-app
+```
+
+### Running tests
+
+```bash
+pytest 
+```

app_python/main.py

@@ -0,0 +1,47 @@
+import datetime as dt
+import pytz
+import time
+from fastapi import FastAPI, Response
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+from fastapi.requests import Request
+from prometheus_client import Summary, Counter, generate_latest, CONTENT_TYPE_LATEST
+
+# Initialize FastAPI app
+app = FastAPI()
+
+# Set up Jinja2 for rendering templates
+templates = Jinja2Templates(directory="templates")
+
+
+def get_moscow_time():
+    """Returns the current time in Moscow as a dictionary."""
+    now = dt.datetime.now(pytz.timezone('Europe/Moscow'))
+    return {"hours": now.hour, "minutes": now.minute, "seconds": now.second}
+
+
+@app.get("/", response_class=HTMLResponse)
+async def show_moscow_time(request: Request):
+    """Renders the Moscow time page."""
+    time_data = get_moscow_time()
+    return templates.TemplateResponse("index.html",
+                                      {"request": request, **time_data})
+
+
+# Prometheus metrics definitions
+REQUEST_TIME = Summary(
+    "request_processing_seconds",
+    "Time spent processing request"
+)
+
+REQUEST_COUNT = Counter(
+    "request_total",
+    "Total number of requests"
+)
+
+@app.get("/metrics")
+def metrics():
+    return Response(
+        generate_latest(),
+        media_type=CONTENT_TYPE_LATEST
+    )

app_python/requirements.txt

@@ -0,0 +1,8 @@
+fastapi==0.111.1
+fastapi-cli==0.0.4
+pytz==2022.1
+uvicorn==0.30.3
+jinja2==3.1.4
+pytest==8.3.4
+flake8==7.1.1
+prometheus_client==0.20.0