1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
|
package main
import (
"fmt"
"log"
"net/http"
"os"
"sync"
"time"
)
// Globals are generally discouraged, but this is a very simple program, and we
// are designing with concurrent access in mind.
// Creating a custom struct with a lock, so we can lock access to the object
type status struct {
value int
sync.Mutex
}
// ReadyValue indiciates the program is ready to receive traffic
var ReadyValue = status{value: http.StatusOK}
// LiveValue indiciates the program is alive and should not be terminated
var LiveValue = status{value: http.StatusOK}
var hostname string
func makeNotReady(w http.ResponseWriter, r *http.Request) {
// Lock access to the variable, then set our global ReadyValue to a failing
// value before sending the response
ReadyValue.Lock()
ReadyValue.value = http.StatusBadRequest
ReadyValue.Unlock()
w.Header().Set("responding-pod", hostname)
fmt.Fprintf(w, "%s", "Set Readiness Value to a failure state")
}
// Hitting this endpoint (by any means) will
func makePodReady(w http.ResponseWriter, r *http.Request) {
ReadyValue.Lock()
ReadyValue.value = http.StatusOK
ReadyValue.Unlock()
w.Header().Set("responding-pod", hostname)
fmt.Fprintf(w, "%s", "Set Readiness Value to successful (OK) state")
}
// This function guarantees Kubernetes will kill the pod
func killMe(w http.ResponseWriter, r *http.Request) {
LiveValue.Lock()
LiveValue.value = http.StatusBadRequest
LiveValue.Unlock()
w.Header().Set("responding-pod", hostname)
fmt.Fprintf(w, "%s", "Set Liveness Value to a failure state")
}
// Provides Ready state to Kubernetes for receiving/stopping traffic
func readinessCheck(w http.ResponseWriter, r *http.Request) {
w.Header().Set("responding-pod", hostname)
ReadyValue.Lock()
http.Error(w, "Responding with ReadyValue", ReadyValue.value)
ReadyValue.Unlock()
}
// Endpoint checked internally by Kubernetes
func livenessCheck(w http.ResponseWriter, r *http.Request) {
w.Header().Set("responding-pod", hostname)
LiveValue.Lock()
http.Error(w, "Responding with LiveValue", LiveValue.value)
LiveValue.Unlock()
}
// The default endpoint
func rootHandler(w http.ResponseWriter, r *http.Request) {
w.Header().Set("responding-pod", hostname)
fmt.Fprintf(w, "%s", "I'm serving traffic!")
}
func main() {
// Force log output to stdout for Docker
log.SetOutput(os.Stdout)
// Finish startup
hostname, _ = os.Hostname()
log.Println("Service started on port 80")
// Set up a custom mutex to add custom handlers. [Note] this level of breakout
// is not required, as we could reasonably compact this into a single call,
// but would lose some readability. This also makes it easy for us to use a
// custom muxer (e.g. gorillamux), custom server, etc
mux := http.NewServeMux()
mux.HandleFunc("/", rootHandler)
mux.HandleFunc("/ping", livenessCheck)
mux.HandleFunc("/ready", readinessCheck)
mux.HandleFunc("/makeNotReady", makeNotReady)
mux.HandleFunc("/makePodReady", makePodReady)
mux.HandleFunc("/killMe", killMe)
server := &http.Server{
Addr: ":80",
Handler: mux,
ReadTimeout: 3 * time.Second,
WriteTimeout: 3 * time.Second,
}
// Actually run our server
if err := server.ListenAndServe(); err != nil {
log.Fatalln(err)
}
}
|
