-
-
Notifications
You must be signed in to change notification settings - Fork 1.1k
/
kubernetes.go
138 lines (111 loc) · 4.13 KB
/
kubernetes.go
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
package suites
import (
"fmt"
"os/exec"
"strings"
"time"
"github.com/authelia/authelia/v4/internal/utils"
)
var kindImageName = "authelia-kind-proxy"
var dockerCmdLine = fmt.Sprintf("docker-compose -p authelia -f internal/suites/docker-compose.yml -f internal/suites/example/compose/kind/docker-compose.yml run --rm %s", kindImageName)
// Kind used for running kind commands.
type Kind struct{}
func kindCommand(cmdline string) *exec.Cmd {
cmd := fmt.Sprintf("%s %s", dockerCmdLine, cmdline)
return utils.Shell(cmd)
}
// CreateCluster create a new Kubernetes cluster.
func (k Kind) CreateCluster() error {
cmd := kindCommand("kind create cluster --config /etc/kind/config.yml")
if err := cmd.Run(); err != nil {
return err
}
cmd = kindCommand("patch-kubeconfig.sh")
if err := cmd.Run(); err != nil {
return err
}
// This command is necessary to fix the coredns loop detected when using user-defined docker network.
// In that case /etc/resolv.conf use 127.0.0.11 as DNS and CoreDNS thinks it is talking to itself which is wrong.
// This IP is the docker internal DNS so it is safe to disable the loop check.
cmd = kindCommand("sh -c 'kubectl -n kube-system get configmap/coredns -o yaml | grep -v loop | kubectl replace -f -'")
err := cmd.Run()
return err
}
// DeleteCluster delete a Kubernetes cluster.
func (k Kind) DeleteCluster() error {
cmd := kindCommand("kind delete cluster")
return cmd.Run()
}
// ClusterExists check whether a cluster exists.
func (k Kind) ClusterExists() (bool, error) {
cmd := kindCommand("kind get clusters")
cmd.Stdout = nil
cmd.Stderr = nil
output, err := cmd.Output()
if err != nil {
return false, err
}
return strings.Contains(string(output), "kind"), nil
}
// LoadImage load an image in the Kubernetes container.
func (k Kind) LoadImage(imageName string) error {
cmd := kindCommand(fmt.Sprintf("kind load docker-image %s", imageName))
return cmd.Run()
}
// Kubectl used for running kubectl commands.
type Kubectl struct{}
// StartProxy start a proxy.
func (k Kubectl) StartProxy() error {
cmd := utils.Shell("docker-compose -p authelia -f internal/suites/docker-compose.yml -f internal/suites/example/compose/kind/docker-compose.yml up -d authelia-kind-proxy")
return cmd.Run()
}
// StopProxy stop a proxy.
func (k Kubectl) StopProxy() error {
cmd := utils.Shell("docker-compose -p authelia -f internal/suites/docker-compose.yml -f internal/suites/example/compose/kind/docker-compose.yml rm -s -f authelia-kind-proxy")
return cmd.Run()
}
// StartDashboard start Kube dashboard.
func (k Kubectl) StartDashboard() error {
if err := kindCommand("sh -c 'cd /authelia && ./bootstrap-dashboard.sh'").Run(); err != nil {
return err
}
err := utils.Shell("docker-compose -p authelia -f internal/suites/docker-compose.yml -f internal/suites/example/compose/kind/docker-compose.yml up -d kube-dashboard").Run()
return err
}
// StopDashboard stop kube dashboard.
func (k Kubectl) StopDashboard() error {
cmd := utils.Shell("docker-compose -p authelia -f internal/suites/docker-compose.yml -f internal/suites/example/compose/kind/docker-compose.yml rm -s -f kube-dashboard")
return cmd.Run()
}
// DeployThirdparties deploy thirdparty services (ldap, db, ingress controllers, etc...).
func (k Kubectl) DeployThirdparties() error {
cmd := kindCommand("sh -c 'cd /authelia && ./bootstrap.sh'")
return cmd.Run()
}
// DeployAuthelia deploy Authelia application.
func (k Kubectl) DeployAuthelia() error {
cmd := kindCommand("sh -c 'cd /authelia && ./bootstrap-authelia.sh'")
return cmd.Run()
}
// WaitPodsReady wait for all pods to be ready.
func (k Kubectl) WaitPodsReady(timeout time.Duration) error {
return utils.CheckUntil(5*time.Second, timeout, func() (bool, error) {
cmd := kindCommand("kubectl get -n authelia pods --no-headers")
cmd.Stdout = nil
cmd.Stderr = nil
output, _ := cmd.Output()
lines := strings.Split(string(output), "\n")
nonEmptyLines := make([]string, 0)
for _, line := range lines {
if line != "" {
nonEmptyLines = append(nonEmptyLines, line)
}
}
for _, line := range nonEmptyLines {
if !strings.Contains(line, "1/1") {
return false, nil
}
}
return true, nil
})
}