MyIP

MyIP is a self‑hosted, full‑stack web application that consolidates a broad range of network diagnostics and IP‑related tooling into a single, responsive interface. Built with modern web technologies, it exposes both an interactive UI and a set of RESTful endpoints that allow developers to embed IP intelligence into their own services. The application is designed to run in any containerized environment or as a native binary, making it ideal for integration into CI/CD pipelines, internal dashboards, or edge‑computing nodes.

Key Features & Core Capabilities

• IP Discovery & Metadata: Aggregates public IPs from multiple providers, enriches them with ASN, geolocation, and ISP data via third‑party APIs (e.g., ipinfo.io), and exposes the results through a /api/ip endpoint.
• Network Diagnostics: Implements latency, traceroute (MTR), and DNS resolution tests against a configurable list of edge servers. These operations are orchestrated by lightweight Go workers that run asynchronously and return JSON payloads to the frontend.
• Security & Privacy Tools: Includes WebRTC leak detection, DNS‑leak testing, and a comprehensive cybersecurity checklist (258 items) that can be queried programmatically.
• Extensibility: Supports custom plug‑ins through a simple Node.js hook system, allowing developers to inject additional data sources or transform responses before they reach the client.
• PWA & Dark Mode: The single‑page application is built with Vue 3 and Vite, leveraging Service Workers for offline support and system‑wide theme detection.

Technical Stack & Architecture

• Backend: Go 1.22 (Gin‑based HTTP server) handles API routing, background task scheduling, and data aggregation. Go’s concurrency model keeps latency low even when performing multiple network probes concurrently.
• Frontend: Vue 3 + Pinia for state management, Vite as the build tool. The UI is highly modular, with each diagnostic feature encapsulated in a reusable component.
• Data Layer: Relies on an in‑memory cache (Go’s sync.Map) for transient probe results; persistent storage is optional and can be swapped with PostgreSQL or SQLite if long‑term analytics are required.
• Containerization: Dockerfile is minimal, exposing port 8080. The image is built on Alpine Linux and supports multi‑stage builds to keep the runtime footprint below 60 MB.

Deployment & Infrastructure

• Self‑Hosting: A single container is sufficient; expose the port via a reverse proxy (NGINX, Traefik) to add TLS termination and HTTP/2 support. The application can also be run directly on bare metal or within Kubernetes as a Deployment with a ConfigMap for provider endpoints.
• Scalability: Horizontal scaling is straightforward; each instance can be load‑balanced behind a CDN. Since the backend is stateless apart from cache, multiple replicas can share a Redis instance for coordinated caching if desired.
• Resource Footprint: Under typical load, CPU usage stays below 5 % and memory under 128 MiB on a standard cloud VM, making it suitable for low‑cost edge nodes.

Integration & Extensibility

• APIs: Exposes REST endpoints (/api/ip, /api/diagnostics/*) that return JSON. The API is documented with OpenAPI annotations, enabling automatic client generation in TypeScript or Go.
• Webhooks: Developers can register webhook URLs to receive push notifications when a probe fails or when new IP data is available.
• Plugin System: The Node.js hook framework allows third‑party modules to register new diagnostic steps or data enrichments without modifying core code. Plugins are isolated in separate NPM packages and can be added via a simple npm install command.
• Customization: Theme, language, and feature flags can be toggled via a configuration file (config.yaml) or environment variables, giving full control over the user experience.

Developer Experience

• Documentation: The README and accompanying docs/ folder provide clear API examples, architecture diagrams, and deployment guides. Inline comments in the Go source make it easy to trace request handling.
• Community & Support: The project is listed on Awesome Self‑Hosted and has an active GitHub Discussions thread for feature requests and bug reports. Licensing under MIT ensures no vendor lock‑in.
• Testing: Includes unit tests for core logic and integration tests that spin up a test container, ensuring regressions are caught early.

Use Cases

• DevOps Dashboards: Embed the IP and network diagnostics widgets into Prometheus or Grafana dashboards to monitor internal VPN health.
• Compliance Audits: Use the DNS‑leak and WebRTC tests to verify that corporate networks meet privacy standards before onboarding new users.
• Edge Deployment: Run MyIP on a Raspberry Pi at the network edge to provide local users with instant latency and connectivity diagnostics without exposing them to external services.
• Security Operations: Automate the cybersecurity checklist as part of a nightly scan pipeline, flagging missing hardening steps before they become vulnerabilities.

Advantages Over Alternatives

• Unified Toolset: Unlike standalone utilities (e.g., mtr, dnsleaktest.com), MyIP bundles all diagnostics into a single, self‑hosted service.
• Performance: Go’s compiled binaries and concurrency model deliver sub‑second latency for most probes, outperforming many JavaScript‑only solutions.