From 7fbaf5c94a85fc263f8eb174cddffa147afe35a4 Mon Sep 17 00:00:00 2001 From: rudolf Date: Fri, 16 Oct 2026 18:28:59 +0200 Subject: [PATCH] k3s --- .gitea/workflows/build-k3s-image.yaml | 21 ++ .gitea/workflows/release.yml | 49 ---- Dockerfile | 12 - __pycache__/app.cpython-312.pyc | Bin 0 -> 18360 bytes __pycache__/network_map.cpython-312.pyc | Bin 0 -> 3993 bytes app.py | 64 ++++- k3s/Dockerfile | 10 + k3s/README.md | 85 +++++++ k3s/__pycache__/app.cpython-312.pyc | Bin 0 -> 18155 bytes k3s/__pycache__/test_app.cpython-312.pyc | Bin 0 -> 1865 bytes k3s/app.py | 297 +++++++++++++++++++++++ k3s/https-patch.yaml | 32 +++ k3s/kubernetes.yaml | 134 ++++++++++ k3s/kustomization.yaml | 4 + k3s/test_app.py | 31 +++ requirements.txt | 1 + stack-compose.yml | 27 ++- 17 files changed, 688 insertions(+), 79 deletions(-) create mode 100644 .gitea/workflows/build-k3s-image.yaml delete mode 100644 .gitea/workflows/release.yml delete mode 100644 Dockerfile create mode 100644 __pycache__/app.cpython-312.pyc create mode 100644 __pycache__/network_map.cpython-312.pyc create mode 100644 k3s/Dockerfile create mode 100644 k3s/README.md create mode 100644 k3s/__pycache__/app.cpython-312.pyc create mode 100644 k3s/__pycache__/test_app.cpython-312.pyc create mode 100644 k3s/app.py create mode 100644 k3s/https-patch.yaml create mode 100644 k3s/kubernetes.yaml create mode 100644 k3s/kustomization.yaml create mode 100644 k3s/test_app.py create mode 100644 requirements.txt diff --git a/.gitea/workflows/build-k3s-image.yaml b/.gitea/workflows/build-k3s-image.yaml new file mode 100644 index 0000000..d4222e1 --- /dev/null +++ b/.gitea/workflows/build-k3s-image.yaml @@ -0,0 +1,21 @@ +name: Build K3s Connectivity Image + +on: + push: + paths: + - k3s/** + - .gitea/workflows/build-k3s-image.yaml + pull_request: + paths: + - k3s/** + - .gitea/workflows/build-k3s-image.yaml + workflow_dispatch: + +jobs: + build: + runs-on: ubuntu-latest + steps: + - name: Check out source + uses: actions/checkout@v4 + - name: Build image + run: docker build --pull --tag k3s-connectivity-tester:${{ gitea.sha }} ./k3s \ No newline at end of file diff --git a/.gitea/workflows/release.yml b/.gitea/workflows/release.yml deleted file mode 100644 index 0d9e7da..0000000 --- a/.gitea/workflows/release.yml +++ /dev/null @@ -1,49 +0,0 @@ -name: release - -on: - push: - branches: - - 'auto-*' - tags: - - 'v*' - workflow_dispatch: - inputs: - tag: - description: 'Image tag (e.g. auto-)' - required: false - default: latest - type: string - -jobs: - build: - runs-on: ubuntu-latest - steps: - - name: checkout - uses: actions/checkout@v4 - - - name: log into Gitea Packages - uses: docker/login-action@v3 - with: - registry: gitea.rudolf.keenetic.link - username: ${{ secrets.REGISTRY_USERNAME }} - password: ${{ secrets.REGISTRY_TOKEN }} - - - name: resolve version - id: version - run: | - if [ -n "${{ inputs.tag }}" ] && [ "${{ inputs.tag }}" != "latest" ]; then - echo "VERSION=${{ inputs.tag }}" >> "$GITHUB_OUTPUT" - else - echo "VERSION=${GITHUB_REF_NAME##*/}" >> "$GITHUB_OUTPUT" - fi - echo "VERSION=$VERSION" - - - name: build and push - uses: docker/build-push-action@v6 - with: - context: . - file: Dockerfile - push: true - tags: | - gitea.rudolf.keenetic.link/org1/swarm_connectivity_tester:${{ steps.version.outputs.VERSION }} - gitea.rudolf.keenetic.link/org1/swarm_connectivity_tester:latest diff --git a/Dockerfile b/Dockerfile deleted file mode 100644 index 65dc943..0000000 --- a/Dockerfile +++ /dev/null @@ -1,12 +0,0 @@ -FROM python:3.12-slim - -WORKDIR /app -COPY . /app/ - -RUN pip install --no-cache-dir docker==7.1.0 - -ENV PYTHONUNBUFFERED=1 \ - PERIOD_SECONDS=600 \ - CHECK_TIMEOUT_S=3 - -CMD ["python", "-m", "app"] diff --git a/__pycache__/app.cpython-312.pyc b/__pycache__/app.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b5ae0006e69f6f466527cdc9bdd5d7cc6a88476a GIT binary patch literal 18360 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 literal 0 HcmV?d00001 diff --git a/__pycache__/network_map.cpython-312.pyc b/__pycache__/network_map.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..be6befadec7bfddbfcf886b970c94e53886f312f GIT binary patch literal 3993 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 Qc~__3VBa2UnmXR_KbyQK`v3p{ literal 0 HcmV?d00001 diff --git a/app.py b/app.py index e34c6e3..ce21812 100644 --- a/app.py +++ b/app.py @@ -11,16 +11,15 @@ each round a final loop checks PUBLIC_SERVICES. Cross-validation: from __future__ import annotations import asyncio +import argparse +import importlib import logging import os import socket +import subprocess import sys import time -from typing import Iterable, List, Set, Tuple - -import docker -from docker.models.containers import Container -from docker.models.networks import Network +from typing import Any, Iterable, List, Set, Tuple from network_map import Endpoint, GLOBAL_SERVICES, NEGATIVE, NETWORK_MAP, PUBLIC_SERVICES @@ -34,7 +33,7 @@ def _socket_path() -> str: return os.environ.get("DOCKER_SOCKET", "/var/run/docker.sock") -def _self_container(client: docker.DockerClient) -> Container: +def _self_container(client: Any) -> Any: hostname = socket.gethostname() for c in client.containers.list(): cn = c.name.lstrip("/") @@ -47,7 +46,7 @@ def _self_container(client: docker.DockerClient) -> Container: raise RuntimeError(f"self container not found for hostname={hostname}") -def _swarm_networks_for(client: docker.DockerClient, +def _swarm_networks_for(client: Any, names: Iterable[str]) -> dict: out = {} by_name = {n.name: n for n in client.networks.list()} @@ -58,8 +57,7 @@ def _swarm_networks_for(client: docker.DockerClient, return out -def _attach(client: docker.DockerClient, container: Container, - network: Network) -> bool: +def _attach(client: Any, container: Any, network: Any) -> bool: current = (container.attrs.get("NetworkSettings", {}) or {}).get("Networks", {}) if network.name in current: return False @@ -73,8 +71,7 @@ def _attach(client: docker.DockerClient, container: Container, raise -def _detach(client: docker.DockerClient, container: Container, - network: Network) -> None: +def _detach(client: Any, container: Any, network: Any) -> None: try: network.disconnect(container, force=True) except Exception as exc: @@ -214,7 +211,7 @@ async def _check_negative(endpoints: List[Endpoint], return leaks -async def main() -> int: +async def run_checks() -> int: logging.basicConfig( level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s", @@ -224,6 +221,7 @@ async def main() -> int: timeout = float(os.environ.get("CHECK_TIMEOUT_S", "3")) LOG.info("starting; period=%ds timeout=%.1fs", period, timeout) + docker = importlib.import_module("docker") client = docker.DockerClient(base_url="unix://" + _socket_path()) self_container = _self_container(client) @@ -272,5 +270,45 @@ async def main() -> int: await asyncio.sleep(sleep_for) +def _healthcheck() -> int: + try: + with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as docker_socket: + docker_socket.connect(_socket_path()) + except OSError as exc: + print(f"Docker socket is unavailable: {exc}", file=sys.stderr) + return 1 + return 0 + + +def _entrypoint() -> int: + socket_path = _socket_path() + if not os.path.exists(socket_path): + print(f"connectivity-tester: Docker socket is missing: {socket_path}", + file=sys.stderr) + return 1 + + subprocess.run( + [sys.executable, "-m", "pip", "install", "--disable-pip-version-check", + "--no-cache-dir", "--requirement", "/app/requirements.txt"], + check=True, + ) + os.execv(sys.executable, [sys.executable, __file__]) + return 0 + + +def main() -> int: + parser = argparse.ArgumentParser() + modes = parser.add_mutually_exclusive_group() + modes.add_argument("--entrypoint", action="store_true") + modes.add_argument("--healthcheck", action="store_true") + args = parser.parse_args() + + if args.entrypoint: + return _entrypoint() + if args.healthcheck: + return _healthcheck() + return asyncio.run(run_checks()) + + if __name__ == "__main__": - asyncio.run(main()) + raise SystemExit(main()) diff --git a/k3s/Dockerfile b/k3s/Dockerfile new file mode 100644 index 0000000..2aa24e6 --- /dev/null +++ b/k3s/Dockerfile @@ -0,0 +1,10 @@ +FROM python:3.12-alpine + +WORKDIR /app +COPY app.py /app/app.py + +ENV PYTHONDONTWRITEBYTECODE=1 +USER 65532:65532 +EXPOSE 8080 + +ENTRYPOINT ["python", "/app/app.py"] \ No newline at end of file diff --git a/k3s/README.md b/k3s/README.md new file mode 100644 index 0000000..49a64b8 --- /dev/null +++ b/k3s/README.md @@ -0,0 +1,85 @@ +# K3s Cross-Node Connectivity Tester + +This workload checks HTTP connectivity between StatefulSet pods by their +individual internal DNS names. A successful `/probe` response includes the +source and peer node names and reports `all_cross_node: true` only when every +peer responded from a different node. + +The default deployment uses two replicas and HTTP on port `8080`. + +## Build and distribute the image + +Build the image from this directory: + +```sh +docker build -t k3s-connectivity-tester:0.1.0 . +``` + +For a multi-node K3s cluster, publish that image to a registry reachable by +every node, then change `image:` in `kubernetes.yaml` to its full registry +name and set `imagePullPolicy: Always`. Alternatively, import the local image +into the K3s containerd image store on every node: + +```sh +docker save k3s-connectivity-tester:0.1.0 | sudo k3s ctr images import - +``` + +## Deploy and verify HTTP + +```sh +kubectl apply -k . +kubectl -n connectivity-test rollout status statefulset/k3s-connectivity +kubectl -n connectivity-test get pods -o wide +``` + +The two pods must show different values in the `NODE` column. This is enforced +by required pod anti-affinity and a `DoNotSchedule` hostname spread rule. On a +single-node cluster, the second pod deliberately remains Pending rather than +silently testing same-node traffic. + +Run an immediate probe from the first pod: + +```sh +kubectl -n connectivity-test exec k3s-connectivity-0 -- \ + python -c "from urllib.request import urlopen; print(urlopen('http://localhost:8080/probe').read().decode())" +``` + +The response contains a peer URL such as: + +```text +http://k3s-connectivity-1.k3s-connectivity.connectivity-test.svc.cluster.local:8080/healthz +``` + +Check the latest periodic result without triggering another request: + +```sh +kubectl -n connectivity-test exec k3s-connectivity-0 -- \ + python -c "from urllib.request import urlopen; print(urlopen('http://localhost:8080/results').read().decode())" +``` + +`all_reachable` and `all_cross_node` must both be `true`. The response also +includes the exact source and peer node names, which makes failed placement or +network-policy diagnosis straightforward. + +## Enable HTTPS + +Create a TLS Secret in the workload namespace, then apply the included +strategic merge patch: + +```sh +kubectl -n connectivity-test create secret tls k3s-connectivity-tls \ + --cert=tls.crt --key=tls.key +kubectl -n connectivity-test patch statefulset k3s-connectivity \ + --type=strategic --patch-file=https-patch.yaml +kubectl -n connectivity-test rollout status statefulset/k3s-connectivity +``` + +The HTTPS patch disables certificate verification for a self-signed diagnostic +certificate. For a certificate issued by a trusted internal CA with SANs for +the pod DNS names, set `VERIFY_TLS` to `true` in the StatefulSet. + +To remove the test: + +```sh +kubectl delete -k . +``` \ No newline at end of file diff --git a/k3s/__pycache__/app.cpython-312.pyc b/k3s/__pycache__/app.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..10f3216386d49f3f03b73ced1a42c0d1b558bb02 GIT binary patch literal 18155 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 literal 0 HcmV?d00001 diff --git a/k3s/__pycache__/test_app.cpython-312.pyc b/k3s/__pycache__/test_app.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..14dcd1a5c50c1143f0c0154f9fd558374872d694 GIT binary patch literal 1865 zcmb7F%}*Og6rb5$+iSC?e5Eo;K}jGaZiEd%Y15XpvcMvVz_x%?ilu6_-5sbMe|2UJ z!2*e@R3%cSq$eV^QZ6~9;*w*f{t3NcQWa~PL#3*R-kh2$DyP0#Y+?wl)Uh=4-t2q7 zc{A_*o`3ZFeF(W| zcf;}JDlo-JD%54VZeKu%bw~(owf+6(d9$uyw1k&%(EW$dV?k`IGt{zDxp{6hn@e@2 z_67(WfSJT5N=l|;N^43|hE;}D0VJ30Zy?N4Zt<9bn}9qZizsV*4vuy3E!{Yw$=JlE zWD0E8x5{SSas@BrbmOg>ZQTbJ(lSbmbB>Hetd& zZ3@_|$fn0s=cUbhWElM$uIcRtzqFIv!+56erS}qGVh48-1zTdJw%a3o(8%X<)UZ+u zDQl_J-mDE;@OmY`ktuSEvQQ>(=ouT21QlD2BoZVRnTp!}M10(lW)hLHsNFg?d2?nq zI!(soQ<3X2Tb+(3Ca;f0W=b7L&l(&)W^d@2y-Q47zcld*z)#qAcIbIPpfr$xA}lGC%)RzAsd3$CqjnwhgzUN2AE z)9`WE1qFal!`OQ#oTX+;506J?BVo>rFkjSJmNbV)#OqQPhC76XNc2J>R9Lb@j?x?w zDRN4bci7;Hx25SIfFuZADM(~hg_o?lgMM-7zKz>|reyGI`nJQ#R*@tcd= z-J=!l^w!z8s14mZ}?h{rjdBt@D25?u~o#yYY&4^Dmd|_5J;)2c5ji1*d-K zj9gI<@l|vghp+1(YzPJ%FcvoI!#d!ui5vBP8DV4{@btKDCD@(94c21O>EPG!hrWdR z&@ke75m<8z(8SIi`4(ElK^ba0F&&?ckHsf#*)j@H9_{;;Gp(mM<X{;q zGL~mf)iKcrgP66$!o@vKvlB4eXPl&`atnGUWs(BRTX`d&At_E6O#?frSqdMM=l^mL z4S~N4(<-X?+jsnZWq;qJ8&7;s{qH?T*gNt}>)O$J%39BZ(&Nipy~96gmtM%Q|3Z9p zEcUn;+&2POck#kojQsPV^vs^sL8mdWcF5hmyup-e0 literal 0 HcmV?d00001 diff --git a/k3s/app.py b/k3s/app.py new file mode 100644 index 0000000..ffec221 --- /dev/null +++ b/k3s/app.py @@ -0,0 +1,297 @@ +#!/usr/bin/env python3 +"""HTTP/HTTPS connectivity probe for StatefulSet pods.""" +from __future__ import annotations + +import argparse +import json +import logging +import os +import socket +import ssl +import threading +from concurrent.futures import ThreadPoolExecutor, as_completed +from dataclasses import asdict, dataclass +from datetime import datetime, timezone +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer +from pathlib import Path +from typing import Any, Mapping +from urllib.error import HTTPError, URLError +from urllib.parse import urlsplit +from urllib.request import Request, urlopen + +LOG = logging.getLogger("k3s-connectivity") + + +@dataclass(frozen=True) +class Settings: + app_name: str + namespace: str + cluster_domain: str + replicas: int + protocol: str + port: int + request_timeout_seconds: float + probe_interval_seconds: float + verify_tls: bool + tls_cert_file: str + tls_key_file: str + + @classmethod + def from_env(cls, environment: Mapping[str, str] | None = None) -> "Settings": + environment = environment or os.environ + protocol = environment.get("PROTOCOL", "http").lower() + if protocol not in {"http", "https"}: + raise ValueError("PROTOCOL must be either http or https") + + replicas = int(environment.get("REPLICAS", "2")) + port = int(environment.get("PORT", "8080")) + timeout = float(environment.get("REQUEST_TIMEOUT_SECONDS", "5")) + interval = float(environment.get("PROBE_INTERVAL_SECONDS", "30")) + if replicas < 1 or port < 1 or timeout <= 0 or interval < 0: + raise ValueError("invalid replicas, port, timeout, or probe interval") + + return cls( + app_name=environment.get("APP_NAME", "k3s-connectivity"), + namespace=environment.get("POD_NAMESPACE", "default"), + cluster_domain=environment.get("CLUSTER_DOMAIN", "cluster.local"), + replicas=replicas, + protocol=protocol, + port=port, + request_timeout_seconds=timeout, + probe_interval_seconds=interval, + verify_tls=environment.get("VERIFY_TLS", "false").lower() + in {"1", "true", "yes"}, + tls_cert_file=environment.get("TLS_CERT_FILE", "/tls/tls.crt"), + tls_key_file=environment.get("TLS_KEY_FILE", "/tls/tls.key"), + ) + + def peer_targets(self, hostname: str) -> list["PeerTarget"]: + local_name = hostname.split(".", maxsplit=1)[0] + suffix = f"{self.app_name}.{self.namespace}.svc.{self.cluster_domain}" + return [ + PeerTarget( + ordinal=ordinal, + name=f"{self.app_name}-{ordinal}", + host=f"{self.app_name}-{ordinal}.{suffix}", + ) + for ordinal in range(self.replicas) + if f"{self.app_name}-{ordinal}" != local_name + ] + + +@dataclass(frozen=True) +class PeerTarget: + ordinal: int + name: str + host: str + + +@dataclass(frozen=True) +class PodIdentity: + hostname: str + node_name: str + pod_ip: str + + @classmethod + def local(cls) -> "PodIdentity": + return cls( + hostname=socket.gethostname(), + node_name=os.environ.get("NODE_NAME", ""), + pod_ip=os.environ.get("POD_IP", ""), + ) + + +class ProbeStore: + def __init__(self) -> None: + self._lock = threading.Lock() + self._latest: dict[str, Any] | None = None + + def replace(self, report: dict[str, Any]) -> None: + with self._lock: + self._latest = report + + def latest(self) -> dict[str, Any]: + with self._lock: + return self._latest or {"state": "not-run"} + + +def _timestamp() -> str: + return datetime.now(timezone.utc).isoformat() + + +def _ssl_context(settings: Settings) -> ssl.SSLContext | None: + if settings.protocol != "https" or settings.verify_tls: + return None + return ssl._create_unverified_context() + + +def probe_peer(target: PeerTarget, settings: Settings, + source: PodIdentity) -> dict[str, Any]: + url = f"{settings.protocol}://{target.host}:{settings.port}/healthz" + checked_at = _timestamp() + request = Request(url, headers={"Accept": "application/json"}) + try: + with urlopen(request, timeout=settings.request_timeout_seconds, + context=_ssl_context(settings)) as response: + payload = json.loads(response.read().decode("utf-8")) + peer = payload.get("pod", {}) + peer_node = peer.get("node_name", "") + return { + "target": target.name, + "url": url, + "checked_at": checked_at, + "success": 200 <= response.status < 300, + "status": response.status, + "peer_hostname": peer.get("hostname", ""), + "peer_node": peer_node, + "cross_node": bool(source.node_name and peer_node) + and source.node_name != peer_node, + "detail": "ok", + } + except HTTPError as error: + return _failed_result(target, url, checked_at, f"HTTP {error.code}") + except (URLError, OSError, TimeoutError, ValueError) as error: + return _failed_result(target, url, checked_at, str(error)) + + +def _failed_result(target: PeerTarget, url: str, checked_at: str, + detail: str) -> dict[str, Any]: + return { + "target": target.name, + "url": url, + "checked_at": checked_at, + "success": False, + "status": None, + "peer_hostname": "", + "peer_node": "", + "cross_node": False, + "detail": detail, + } + + +class ProbeApplication: + def __init__(self, settings: Settings, identity: PodIdentity) -> None: + self.settings = settings + self.identity = identity + self.store = ProbeStore() + + def health(self) -> dict[str, Any]: + return {"status": "ok", "pod": asdict(self.identity)} + + def probe_now(self) -> dict[str, Any]: + targets = self.settings.peer_targets(self.identity.hostname) + results: list[dict[str, Any]] = [] + if targets: + with ThreadPoolExecutor(max_workers=min(len(targets), 8)) as executor: + futures = { + executor.submit(probe_peer, target, self.settings, self.identity): target + for target in targets + } + for future in as_completed(futures): + results.append(future.result()) + results.sort(key=lambda result: result["target"]) + report = { + "checked_at": _timestamp(), + "source": asdict(self.identity), + "protocol": self.settings.protocol, + "all_reachable": all(result["success"] for result in results), + "all_cross_node": all(result["cross_node"] for result in results), + "peers": results, + } + self.store.replace(report) + return report + + +class ConnectivityRequestHandler(BaseHTTPRequestHandler): + server: ThreadingHTTPServer + + def do_GET(self) -> None: + application: ProbeApplication = getattr(self.server, "application") + path = urlsplit(self.path).path + if path in {"/", "/healthz"}: + self._send_json(200, application.health()) + elif path == "/probe": + report = application.probe_now() + self._send_json(200 if report["all_reachable"] else 503, report) + elif path == "/results": + self._send_json(200, application.store.latest()) + else: + self._send_json(404, {"error": "not found"}) + + def do_HEAD(self) -> None: + self.do_GET() + + def _send_json(self, status: int, payload: dict[str, Any]) -> None: + body = json.dumps(payload, sort_keys=True).encode("utf-8") + self.send_response(status) + self.send_header("Content-Type", "application/json") + self.send_header("Content-Length", str(len(body))) + self.end_headers() + if self.command != "HEAD": + self.wfile.write(body) + + def log_message(self, format_string: str, *arguments: object) -> None: + LOG.info("%s - %s", self.address_string(), format_string % arguments) + + +def _configure_tls(server: ThreadingHTTPServer, settings: Settings) -> None: + if settings.protocol != "https": + return + if not Path(settings.tls_cert_file).is_file() or not Path(settings.tls_key_file).is_file(): + raise FileNotFoundError("TLS_CERT_FILE and TLS_KEY_FILE must reference mounted files") + context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) + context.load_cert_chain(settings.tls_cert_file, settings.tls_key_file) + server.socket = context.wrap_socket(server.socket, server_side=True) + + +def _run_periodic_probes(application: ProbeApplication, + stop_event: threading.Event) -> None: + while not stop_event.is_set(): + report = application.probe_now() + LOG.info("probe complete reachable=%s cross_node=%s peers=%d", + report["all_reachable"], report["all_cross_node"], + len(report["peers"])) + if application.settings.probe_interval_seconds == 0: + return + stop_event.wait(application.settings.probe_interval_seconds) + + +def main() -> int: + parser = argparse.ArgumentParser() + parser.add_argument("--once", action="store_true") + arguments = parser.parse_args() + + logging.basicConfig(level=os.environ.get("LOG_LEVEL", "INFO"), + format="%(asctime)s %(levelname)s %(message)s") + settings = Settings.from_env() + application = ProbeApplication(settings, PodIdentity.local()) + if arguments.once: + report = application.probe_now() + print(json.dumps(report, sort_keys=True)) + return 0 if report["all_reachable"] else 1 + + server = ThreadingHTTPServer(("", settings.port), ConnectivityRequestHandler) + setattr(server, "application", application) + _configure_tls(server, settings) + stop_event = threading.Event() + probe_thread = threading.Thread( + target=_run_periodic_probes, + args=(application, stop_event), + daemon=True, + ) + probe_thread.start() + try: + LOG.info("listening protocol=%s port=%d pod=%s node=%s", + settings.protocol, settings.port, application.identity.hostname, + application.identity.node_name) + server.serve_forever() + except KeyboardInterrupt: + return 0 + finally: + stop_event.set() + server.shutdown() + server.server_close() + + +if __name__ == "__main__": + raise SystemExit(main()) \ No newline at end of file diff --git a/k3s/https-patch.yaml b/k3s/https-patch.yaml new file mode 100644 index 0000000..9f66783 --- /dev/null +++ b/k3s/https-patch.yaml @@ -0,0 +1,32 @@ +apiVersion: apps/v1 +kind: StatefulSet +metadata: + name: k3s-connectivity + namespace: connectivity-test +spec: + template: + spec: + containers: + - name: connectivity-tester + env: + - name: PROTOCOL + value: https + - name: VERIFY_TLS + value: "false" + volumeMounts: + - name: tls + mountPath: /tls + readOnly: true + readinessProbe: + httpGet: + scheme: HTTPS + livenessProbe: + httpGet: + scheme: HTTPS + startupProbe: + httpGet: + scheme: HTTPS + volumes: + - name: tls + secret: + secretName: k3s-connectivity-tls \ No newline at end of file diff --git a/k3s/kubernetes.yaml b/k3s/kubernetes.yaml new file mode 100644 index 0000000..d765633 --- /dev/null +++ b/k3s/kubernetes.yaml @@ -0,0 +1,134 @@ +apiVersion: v1 +kind: Namespace +metadata: + name: connectivity-test +--- +apiVersion: v1 +kind: Service +metadata: + name: k3s-connectivity + namespace: connectivity-test + labels: + app.kubernetes.io/name: k3s-connectivity +spec: + clusterIP: None + publishNotReadyAddresses: true + selector: + app.kubernetes.io/name: k3s-connectivity + ports: + - name: web + port: 8080 + targetPort: web + protocol: TCP +--- +apiVersion: apps/v1 +kind: StatefulSet +metadata: + name: k3s-connectivity + namespace: connectivity-test + labels: + app.kubernetes.io/name: k3s-connectivity +spec: + serviceName: k3s-connectivity + replicas: 2 + podManagementPolicy: Parallel + selector: + matchLabels: + app.kubernetes.io/name: k3s-connectivity + template: + metadata: + labels: + app.kubernetes.io/name: k3s-connectivity + spec: + automountServiceAccountToken: false + terminationGracePeriodSeconds: 10 + affinity: + podAntiAffinity: + requiredDuringSchedulingIgnoredDuringExecution: + - labelSelector: + matchLabels: + app.kubernetes.io/name: k3s-connectivity + topologyKey: kubernetes.io/hostname + topologySpreadConstraints: + - maxSkew: 1 + topologyKey: kubernetes.io/hostname + whenUnsatisfiable: DoNotSchedule + labelSelector: + matchLabels: + app.kubernetes.io/name: k3s-connectivity + containers: + - name: connectivity-tester + image: k3s-connectivity-tester:0.1.0 + imagePullPolicy: IfNotPresent + ports: + - name: web + containerPort: 8080 + protocol: TCP + env: + - name: APP_NAME + value: k3s-connectivity + - name: POD_NAMESPACE + valueFrom: + fieldRef: + fieldPath: metadata.namespace + - name: NODE_NAME + valueFrom: + fieldRef: + fieldPath: spec.nodeName + - name: POD_IP + valueFrom: + fieldRef: + fieldPath: status.podIP + - name: REPLICAS + value: "2" + - name: PROTOCOL + value: http + - name: PORT + value: "8080" + - name: PROBE_INTERVAL_SECONDS + value: "30" + - name: REQUEST_TIMEOUT_SECONDS + value: "5" + readinessProbe: + httpGet: + path: /healthz + port: web + scheme: HTTP + initialDelaySeconds: 2 + periodSeconds: 5 + timeoutSeconds: 2 + failureThreshold: 3 + livenessProbe: + httpGet: + path: /healthz + port: web + scheme: HTTP + initialDelaySeconds: 5 + periodSeconds: 10 + timeoutSeconds: 2 + failureThreshold: 3 + startupProbe: + httpGet: + path: /healthz + port: web + scheme: HTTP + periodSeconds: 2 + failureThreshold: 15 + resources: + requests: + cpu: 25m + memory: 32Mi + limits: + cpu: 100m + memory: 128Mi + securityContext: + allowPrivilegeEscalation: false + capabilities: + drop: + - ALL + readOnlyRootFilesystem: true + runAsNonRoot: true + runAsUser: 65532 + runAsGroup: 65532 + seccompProfile: + type: RuntimeDefault \ No newline at end of file diff --git a/k3s/kustomization.yaml b/k3s/kustomization.yaml new file mode 100644 index 0000000..6837446 --- /dev/null +++ b/k3s/kustomization.yaml @@ -0,0 +1,4 @@ +apiVersion: kustomize.config.k8s.io/v1beta1 +kind: Kustomization +resources: + - kubernetes.yaml \ No newline at end of file diff --git a/k3s/test_app.py b/k3s/test_app.py new file mode 100644 index 0000000..a51fb42 --- /dev/null +++ b/k3s/test_app.py @@ -0,0 +1,31 @@ +import unittest + +from app import Settings + + +class SettingsTests(unittest.TestCase): + def test_peer_targets_use_stable_statefulset_names(self) -> None: + settings = Settings.from_env({ + "APP_NAME": "k3s-connectivity", + "POD_NAMESPACE": "connectivity-test", + "CLUSTER_DOMAIN": "cluster.local", + "REPLICAS": "3", + }) + + targets = settings.peer_targets("k3s-connectivity-1") + + self.assertEqual([target.name for target in targets], [ + "k3s-connectivity-0", "k3s-connectivity-2", + ]) + self.assertEqual( + targets[0].host, + "k3s-connectivity-0.k3s-connectivity.connectivity-test.svc.cluster.local", + ) + + def test_invalid_protocol_is_rejected(self) -> None: + with self.assertRaisesRegex(ValueError, "PROTOCOL"): + Settings.from_env({"PROTOCOL": "tcp"}) + + +if __name__ == "__main__": + unittest.main() \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..de5cce3 --- /dev/null +++ b/requirements.txt @@ -0,0 +1 @@ +docker==7.1.0 \ No newline at end of file diff --git a/stack-compose.yml b/stack-compose.yml index ece5023..eb8bcb2 100644 --- a/stack-compose.yml +++ b/stack-compose.yml @@ -1,19 +1,28 @@ services: connectivity-tester: - build: - context: . - dockerfile: Dockerfile - image: gitea.rudolf.keenetic.link/Org1/swarm_connectivity_tester:${version} + image: docker.io/library/python:3.12-slim hostname: connectivity-tester user: "0:0" + working_dir: /app + entrypoint: ["python", "/app/app.py", "--entrypoint"] volumes: - /var/run/docker.sock:/var/run/docker.sock healthcheck: - test: ["CMD-SHELL", "test -S /var/run/docker.sock"] + test: ["CMD", "python", "/app/app.py", "--healthcheck"] interval: 60s timeout: 5s retries: 3 start_period: 30s + configs: + - source: connectivity_tester_app + target: /app/app.py + mode: 0444 + - source: connectivity_tester_network_map + target: /app/network_map.py + mode: 0444 + - source: connectivity_tester_requirements + target: /app/requirements.txt + mode: 0444 deploy: mode: global resources: @@ -26,3 +35,11 @@ services: condition: on-failure delay: 10s max_attempts: 3 + +configs: + connectivity_tester_app: + file: ./app.py + connectivity_tester_network_map: + file: ./network_map.py + connectivity_tester_requirements: + file: ./requirements.txt