healthcheck 实现了一个开箱即用的Kubernetes liveness&& readiness prob 实现，我们可以直接拿来使用
已经包含了tcp，dns，http，Goroutine prob，同时也支持prometheus，还是很方便的
以下是一个简单的试用
参考代码
package main
import (
"fmt"
"log"
"net/http"
"net/http/httptest"
"net/http/httputil"
"os"
"os/signal"
"strings"
"syscall"
"time"
"github.com/heptiolabs/healthcheck"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/client_golang/prometheus/promhttp"
)
func main() {
registry := prometheus.NewRegistry()
// Create a metrics-exposing Handler for the Prometheus registry
// The healthcheck related metrics will be prefixed with the provided namespace
health := healthcheck.NewMetricsHandler(registry, "example")
// Create a Handler that we can use to register liveness and readiness checks.
// Make sure we can connect to an upstream dependency over TCP in less than
// 50ms. Run this check asynchronously in the background every 10 seconds
// instead of every time the /ready or /live endpoints are hit.
//
// Async is useful whenever a check is expensive (especially if it causes
// load on upstream services).
// upstreamAddr := "upstream.example.com:5432"
// health.AddReadinessCheck(
// "upstream-dep-tcp",
// healthcheck.Async(healthcheck.TCPDialCheck(upstreamAddr, 50*time.Millisecond), 10*time.Second))
// Add a readiness check against the health of an upstream HTTP dependency
upstreamURL := "https://www.cnblogs.com/rongfengliang"
health.AddReadinessCheck(
"upstream-dep-http",
healthcheck.HTTPGetCheck(upstreamURL, 500*time.Millisecond))
// Implement a custom check with a 50 millisecond timeout.
health.AddLivenessCheck("custom-check-with-timeout", healthcheck.Timeout(func() error {
// Simulate some work that could take a long time
time.Sleep(time.Millisecond * 100)
return nil
}, 500*time.Millisecond))
// Expose the readiness endpoints on a custom path /healthz mixed into
// our main application mux.
mux := http.NewServeMux()
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("Hello, world!"))
})
mux.HandleFunc("/healthz", health.LiveEndpoint)
mux.Handle("/metrics", promhttp.HandlerFor(registry, promhttp.HandlerOpts{}))
// Sleep for just a moment to make sure our Async handler had a chance to run
//time.Sleep(500 * time.Millisecond)
go http.ListenAndServe("0.0.0.0:9402", mux)
// Make a sample request to the /healthz endpoint and print the response.
fmt.Println(dumpRequest(mux, "GET", "/healthz"))
sigChan := make(chan os.Signal, 1)
signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
sig := <-sigChan
log.Printf("shutting down %v signal received", sig)
}
func dumpRequest(handler http.Handler, method string, path string) string {
req, err := http.NewRequest(method, path, nil)
if err != nil {
panic(err)
}
rr := httptest.NewRecorder()
handler.ServeHTTP(rr, req)
dump, err := httputil.DumpResponse(rr.Result(), true)
if err != nil {
panic(err)
}
return strings.Replace(string(dump), "
", "
", -1)
}
参考效果
参考资料
https://github.com/heptiolabs/healthcheck
https://godoc.org/github.com/heptiolabs/healthcheck#Handler