Overview of Graphinfo's Core Features
Graphinfo offers an automated solution for infrastructure mapping by leveraging autodiscovery. This eliminates the need for manual inventory management, as the tool connects to the Docker daemon, inspects running containers, and probes databases and storage services. By pointing Graphinfo to your stack, it generates a live, interactive graph that visualizes every database, service, and storage bucket with real-time health monitoring.
Unlike traditional infrastructure tools, Graphinfo does not require external configuration files for initial setup. Instead, it dynamically builds its graph by analyzing the existing ecosystem. This makes it particularly useful for environments with frequently changing topologies or dynamically scaled microservices architectures.
Backend and Frontend Deployment
Graphinfo's deployment process is streamlined using containerized services. The backend can be launched by mounting the Docker socket, facilitating autodiscovery. For instance, the backend is initiated using the Docker command: `docker run -d -p 8080:8080 -v /var/run/docker.sock:/var/run/docker.sock ghcr.io/guilhermegrimm/graphgo-backend:latest`. This step ensures that Graphinfo has direct access to container metadata.
The frontend is separately deployed using a similar containerized approach. By running the provided Docker command, users can access the interactive graph via `http://localhost:3000`. This separation allows for independent scaling and maintenance of the backend and frontend components.
Configuration for External Connections
Graphinfo supports connecting to external infrastructure components such as remote databases or S3 buckets. This is achieved by mounting a configuration file during backend deployment. For example, users can add custom connections by specifying endpoints in a YAML file and mounting it using the Docker volume option: `-v /conf/config.yaml:/app/conf/config.yaml`.
This flexibility enables Graphinfo to extend its mapping capabilities beyond Dockerized environments, making it suitable for hybrid infrastructure setups. Users can tailor connection strings and parameters to adapt the tool to their specific needs.
Local Development and Testing
For developers, Graphinfo provides a robust local setup workflow. By cloning the repository and running the `make docker-up` command, users can launch sample services such as PostgreSQL, MongoDB, and MinIO for testing purposes. This environment is accessible through predefined local endpoints, enabling rapid prototyping and debugging.
The backend can also be executed directly using Go commands. Developers need to install dependencies with `go mod download` and run the application via `go run cmd/app/main.go`. This flexibility ensures compatibility with diverse development pipelines.
Autodiscovery and Kubernetes Integration
Graphinfos autodiscovery mechanism is its most efficient feature, automatically detecting infrastructure elements without manual intervention. By mounting the Docker socket or deploying within a Kubernetes cluster, the tool dynamically updates its graph as containers and services change.
In Kubernetes environments, Graphinfo benefits from native orchestration features. As pods scale or shift across nodes, the graph adjusts in real time, maintaining an accurate view of the entire infrastructure. This makes it invaluable for managing complex distributed systems.
Testing and Production-Ready Builds
Graphinfo includes a well-defined testing framework to ensure stability. Running `make test` executes all test cases, validating both backend and frontend components. This guarantees that new changes do not introduce regressions.
For production deployment, Graphinfo supports building optimized binaries using the `make build` command. These binaries can be deployed on servers or packaged into containers, offering deployment flexibility for various environments. This workflow ensures that the tool can handle real-world demands effectively.