How jorrit05/dynamos works
Main Components
• Clients/External Interfaces: Represent the web frontend (in the “web” directory) and any external API consumers that interact with the system.
• Ingress Layer: At the boundary, include the NGINX ingress (configured with Kubernetes) that routes external requests to the cluster.
• API Gateway: The dedicated microservice (found in go/cmd/api-gateway and its corresponding Helm chart) that accepts and fronts incoming requests.
• Core Orchestration Layer: Include the orchestrator service (go/cmd/orchestrator) that manages request flow and coordinates among services.
• Policy Enforcer: This service (in go/cmd/policy-enforcer) is responsible for validating or modifying requests based on system policies.
• Messaging Infrastructure: RabbitMQ is a central messaging bus that facilitates communication between the microservices (with configuration details, such as the secure password and PVC mounting as explained in the README).
• Shared Data and Configuration Store: Represent etcd as the repository for service configuration, service discovery, and job metadata.
• Observability and Monitoring Components: Include Prometheus (for metrics), Grafana (dashboards), Jaeger (distributed tracing installed via Linkerd), and the Linkerd service mesh layer.
• Supporting Build/Operational Tools: Note the Helm charts in the “charts” directory that package the deployment configuration, the Dockerfiles (in .devcontainer, go, python, etc.) that build images, and scripts/configuration files that automate deployment.
Relationships and Interactions
• External user requests flow through the Ingress, reaching the API Gateway.
• The API Gateway routes requests into the internal system where the Orchestrator processes them.
• The orchestrator then interacts with Agent services and possibly triggers operations in the Policy Enforcer or Sidecar components.
• All microservices communicate with each other via internal APIs (often using gRPC as the protocol) and utilize RabbitMQ for asynchronous messaging.
• Configuration, service registration, and state changes are reported and maintained in etcd.
• Observability tools tap into system metrics and traces across the microservices to form a feedback loop for monitoring.
Architectural Patterns & Design Principles
• Microservices Architecture: Emphasize the separation of concerns, with each service (agent, API gateway, orchestrator, policy enforcer, sidecar, etc.) being an independently deployable unit.
• Configuration as Code: Show that the cloud deployment is automated via Helm charts and Kubernetes manifests, and that deployments are configured dynamically (e.g., RabbitMQ credential generation, PVC filling for definitions).
Including Relevant Technologies and Frameworks
• Languages: Go (for core microservices), Python (for client library), and Vue (for web interface).
• Containerization: Docker images (with Dockerfiles in various directories) and deployment via Kubernetes.
• CI/CD Tools: GitHub Actions (as seen with .github files) and Helm/Makefiles.
• Observability: Prometheus, Grafana, Jaeger integrated via Linkerd.