add a python3 example

Signed-off-by: stoneshi <stoneshi@kubesphere.io>

Author: stoneshi-yunify

Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3-slim
+
+WORKDIR /app
+
+RUN groupadd -r appgroup && useradd -r -g appgroup appuser
+
+COPY server.py ./
+
+RUN chown -R appuser:appgroup /app
+USER appuser
+
+EXPOSE 8080
+
+ENV PORT=8080
+
+CMD ["python", "server.py"]

Makefile

@@ -0,0 +1,40 @@
+PORT ?= 8080
+IMAGE_NAME := python-server:latest
+CONTAINER_NAME := python-server
+
+.PHONY: run test build docker-build docker-run stop clean
+
+run:
+	python3 server.py
+
+test:
+	@echo "Starting server on port $(PORT)..."
+	@( \
+		set -e; \
+		python3 server.py & SERVER_PID=$$!; \
+		trap "kill -9 $$SERVER_PID 2>/dev/null || true" EXIT; \
+		sleep 1; \
+		echo "Testing / endpoint..."; \
+		curl -s -o /dev/null -w "%{http_code}" http://localhost:$(PORT)/ | grep -q '^200$$'; \
+		echo "Testing /health endpoint..."; \
+		curl -s http://localhost:$(PORT)/health | grep -q '"status":"ok"'; \
+		echo "Smoke tests passed."; \
+	)
+
+build:
+	python3 -m py_compile server.py
+	@echo "Build check passed."
+
+docker-build:
+	docker build -t $(IMAGE_NAME) .
+
+docker-run:
+	docker run -d --rm --name $(CONTAINER_NAME) -e PORT=$(PORT) -p $(PORT):$(PORT) $(IMAGE_NAME)
+
+stop:
+	-docker stop $(CONTAINER_NAME)
+	-docker rm $(CONTAINER_NAME) 2>/dev/null || true
+
+clean:
+	find . -type d -name __pycache__ -exec rm -rf {} + 2>/dev/null || true
+	find . -type f -name '*.pyc' -delete 2>/dev/null || true

README.md

@@ -0,0 +1,64 @@
+# Non-Stoppable Python 3 HTTP Server Example
+
+A minimal Python 3 HTTP server that keeps running even when it receives graceful shutdown signals (`SIGTERM` / `SIGINT`). Useful for demonstrating long-running containerized processes.
+
+## Requirements
+
+- Python 3
+- `make` (optional, for convenience)
+- Docker (optional, for containerized run)
+
+## Quick Start
+
+Run locally:
+
+```bash
+make run
+```
+
+Or without `make`:
+
+```bash
+python3 server.py
+```
+
+The server listens on `0.0.0.0:8080` by default. Change the port with the `PORT` environment variable:
+
+```bash
+PORT=9000 python3 server.py
+```
+
+## Endpoints
+
+| Method | Path      | Response                        |
+|--------|-----------|---------------------------------|
+| GET    | `/`       | `Hello, World!` (text/plain)    |
+| GET    | `/health` | `{"status":"ok"}` (application/json) |
+| *      | *         | `404 Not Found`                 |
+
+## Testing
+
+```bash
+make test
+```
+
+This starts the server in the background, verifies both endpoints with `curl`, and then forcefully terminates the process.
+
+## Docker
+
+Build and run:
+
+```bash
+make docker-build
+make docker-run
+```
+
+Stop the container:
+
+```bash
+make stop
+```
+
+## "Non-Stoppable" Behavior
+
+The server registers handlers for `SIGTERM` and `SIGINT`. When either signal arrives, the handler logs the signal and returns, allowing the server to continue serving. The process exits only on `SIGKILL` or an unhandled fatal error.

server.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python3
+"""A non-stoppable Python 3 HTTP server example."""
+
+import json
+import logging
+import os
+import signal
+import sys
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+)
+
+DEFAULT_PORT = 8080
+
+
+class RequestHandler(BaseHTTPRequestHandler):
+    def _send(self, status: int, body: bytes, content_type: str = "text/plain") -> None:
+        self.send_response(status)
+        self.send_header("Content-Type", content_type)
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_GET(self) -> None:  # noqa: N802
+        if self.path == "/":
+            self._send(200, b"Hello, World!\n")
+        elif self.path == "/health":
+            self._send(200, json.dumps({"status": "ok"}, separators=(",", ":")).encode(), "application/json")
+        else:
+            self._send(404, b"Not Found\n")
+
+    def log_message(self, format: str, *args) -> None:  # noqa: A002
+        logging.info("%s - %s", self.address_string(), format % args)
+
+
+def _handle_signal(signum: int, frame) -> None:
+    signal_name = signal.Signals(signum).name
+    logging.info("Received %s; ignoring and continuing to serve.", signal_name)
+
+
+def get_port() -> int:
+    raw = os.environ.get("PORT", str(DEFAULT_PORT))
+    try:
+        return int(raw)
+    except ValueError:
+        logging.warning("Invalid PORT value %r; falling back to %d.", raw, DEFAULT_PORT)
+        return DEFAULT_PORT
+
+
+def main() -> int:
+    port = get_port()
+    server = HTTPServer(("0.0.0.0", port), RequestHandler)
+
+    signal.signal(signal.SIGTERM, _handle_signal)
+    signal.signal(signal.SIGINT, _handle_signal)
+
+    logging.info("Starting non-stoppable server on 0.0.0.0:%d", port)
+    try:
+        server.serve_forever()
+    except Exception as exc:  # noqa: BLE001
+        logging.exception("Server failed: %s", exc)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())