Nautilus
A Go framework for building and running reliable, observable operator services with built-in support for health checks, metrics, API endpoints, and database connections.
Key Features
Run operators once, on a schedule, or at regular intervals to suit your specific use case.
Health checks API endpoints, Prometheus metrics integration, structured logging with zerolog, and Grafana dashboard templates.
Extend functionality with database connectors and more through the flexible plugin architecture.
Ready-to-use PostgreSQL plugin makes database interaction simple and reliable.
Simple, expressive API with functional options pattern for configuration and comprehensive examples.
Graceful shutdown, resource cleanup, error handling, and signal handling for production-ready services.
Quick Start
Installation
go get github.com/navica-dev/nautilusConfiguration
n, err := nautilus.New(
// Basic configuration
nautilus.WithName("my-operator"),
nautilus.WithDescription("My custom operator"),
nautilus.WithVersion("1.0.0"),
// Execution configuration
nautilus.WithInterval(30*time.Second),
// API configuration
nautilus.WithAPI(true, 12911),
// Metrics configuration
nautilus.WithMetrics(true),
)Example Operator
package main
import (
"context"
"log"
"time"
"github.com/navica-dev/nautilus"
"github.com/navica-dev/nautilus/pkg/interfaces"
)
// SimpleOperator implements the interfaces.Operator interface
var _ interfaces.Operator = (*SimpleOperator)(nil)
type SimpleOperator struct {
counter int
}
func (op *SimpleOperator) Initialize(ctx context.Context) error {
op.counter = 0
return nil
}
func (op *SimpleOperator) Run(ctx context.Context) error {
op.counter++
log.Printf("Running operator for the %dth time", op.counter)
return nil
}
func (op *SimpleOperator) Terminate(ctx context.Context) error {
log.Printf("Terminating operator after %d runs", op.counter)
return nil
}
func main() {
ctx := context.Background()
// Create Nautilus instance with options
n, err := nautilus.New(
nautilus.WithName("simple-operator"),
nautilus.WithDescription("A simple example operator"),
nautilus.WithVersion("0.1.0"),
nautilus.WithInterval(5*time.Second),
nautilus.WithAPI(true, 12911),
nautilus.WithMetrics(true),
)
if err != nil {
log.Fatalf("Failed to create Nautilus instance: %v", err)
}
// Create and run the operator
op := &SimpleOperator{}
if err := n.Run(ctx, op); err != nil {
log.Fatalf("Error running operator: %v", err)
}
}Advanced Usage
Creating Custom Plugins
Nautilus supports a plugin system to extend functionality. Here's how to create a custom plugin:
type MyPlugin struct {
// Your plugin fields
}
var _ plugin.Plugin = (*MyPlugin)(nil)
func (p *MyPlugin) Name() string {
return "my-plugin"
}
func (p *MyPlugin) Initialize(ctx context.Context) error {
// Initialize your plugin
return nil
}
func (p *MyPlugin) Terminate(ctx context.Context) error {
// Clean up resources
return nil
}
// Then register it with Nautilus
n, err := nautilus.New(
// ... other options
nautilus.WithPlugin(&MyPlugin{}),
)Development Setup
- Go 1.24+
- Docker and Docker Compose (for running PostgreSQL examples)
1. Clone the repository:
git clone https://github.com/navica-dev/nautilus.git
cd nautilus2. Start the development environment:
cd .devenv
docker-compose up -dThis starts PostgreSQL, PgAdmin, Prometheus, and Grafana services.
3. Run examples:
go run examples/basic/main.go
# or
go run examples/postgres/main.goReady to Get Started?
Try Nautilus today and build reliable, observable operator services with ease.