kuma

1
package kic
2

3
import (
4
	"fmt"
5

6
	. "github.com/onsi/ginkgo/v2"
7
	. "github.com/onsi/gomega"
8

9
	. "github.com/kumahq/kuma/test/framework"
10
	"github.com/kumahq/kuma/test/framework/client"
11
	"github.com/kumahq/kuma/test/framework/deployments/democlient"
12
	"github.com/kumahq/kuma/test/framework/deployments/kic"
13
	"github.com/kumahq/kuma/test/framework/deployments/testserver"
14
	"github.com/kumahq/kuma/test/framework/envs/kubernetes"
15
)
16

17
func KICKubernetes() {
18
	// IPv6 currently not supported by Kong Ingress Controller
19
	// https://github.com/Kong/kubernetes-ingress-controller/issues/1017
20
	if Config.IPV6 {
21
		fmt.Println("Test not supported on IPv6")
22
		return
23
	}
24
	if Config.K8sType == KindK8sType {
25
		// KIC 2.0 when started with service type LoadBalancer requires external IP to be provisioned before it's healthy.
26
		// KIND cannot provision external IP, K3D can.
27
		fmt.Println("Test not supported on KIND")
28
		return
29
	}
30

31
	namespace := "kic"
32
	mesh := "kic"
33
	namespaceOutsideMesh := "kic-external"
34

35
	var kicIP string
36

37
	BeforeAll(func() {
38
		Expect(NewClusterSetup().
39
			Install(MTLSMeshKubernetes(mesh)).
40
			Install(MeshTrafficPermissionAllowAllKubernetes(mesh)).
41
			Install(NamespaceWithSidecarInjection(namespace)).
42
			Install(Namespace(namespaceOutsideMesh)).
43
			Install(democlient.Install(democlient.WithNamespace(namespaceOutsideMesh))). // this will not be in the mesh
44
			Install(kic.KongIngressController(
45
				kic.WithNamespace(namespace),
46
				kic.WithName("kic"),
47
				kic.WithMesh(mesh),
48
			)).
49
			Install(kic.KongIngressService(
50
				kic.WithNamespace(namespace),
51
				kic.WithName("kic"),
52
			)).
53
			Install(testserver.Install(
54
				testserver.WithNamespace(namespace),
55
				testserver.WithMesh(mesh),
56
				testserver.WithName("test-server"),
57
			)).
58
			Setup(kubernetes.Cluster)).To(Succeed())
59

60
		ip, err := kic.From(kubernetes.Cluster).IP(namespace)
61
		Expect(err).To(Succeed())
62

63
		kicIP = ip
64
	})
65

66
	E2EAfterAll(func() {
67
		Expect(kubernetes.Cluster.TriggerDeleteNamespace(namespace)).To(Succeed())
68
		Expect(kubernetes.Cluster.TriggerDeleteNamespace(namespaceOutsideMesh)).To(Succeed())
69
		Expect(kubernetes.Cluster.DeleteMesh(mesh)).To(Succeed())
70
	})
71

72
	It("should route to service using Kube DNS", func() {
73
		ingress := `
74
---
75
apiVersion: gateway.networking.k8s.io/v1
76
kind: GatewayClass
77
metadata:
78
  name: kic
79
  annotations:
80
    konghq.com/gatewayclass-unmanaged: 'true'
81
spec:
82
  controllerName: konghq.com/kic-gateway-controller
83
---
84
apiVersion: gateway.networking.k8s.io/v1
85
kind: Gateway
86
metadata:
87
  name: kong
88
  namespace: kic
89
spec:
90
  gatewayClassName: kic
91
  listeners:
92
  - name: proxy
93
    port: 80
94
    protocol: HTTP
95
---
96
apiVersion: gateway.networking.k8s.io/v1
97
kind: HTTPRoute
98
metadata:
99
  name: echo
100
  namespace: kic
101
  annotations:
102
    konghq.com/strip-path: 'true'
103
spec:
104
  parentRefs:
105
  - name: kong
106
    namespace: kic
107
  rules:
108
  - matches:
109
    - path:
110
        type: PathPrefix
111
        value: /test-server
112
    backendRefs:
113
    - name: test-server
114
      kind: Service
115
      port: 80
116
`
117
		Expect(kubernetes.Cluster.Install(YamlK8s(ingress))).To(Succeed())
118

119
		Eventually(func(g Gomega) {
120
			_, err := client.CollectEchoResponse(
121
				kubernetes.Cluster, "demo-client", fmt.Sprintf("http://%s/test-server", kicIP),
122
				client.FromKubernetesPod(namespaceOutsideMesh, "demo-client"),
123
			)
124
			g.Expect(err).ToNot(HaveOccurred())
125
		}, "30s", "1s").Should(Succeed())
126
	})
127

128
	It("should route to service using Kuma DNS", func() {
129
		const ingressMeshDNS = `
130
---
131
apiVersion: gateway.networking.k8s.io/v1
132
kind: HTTPRoute
133
metadata:
134
  name: echo
135
  namespace: kic
136
  annotations:
137
    konghq.com/strip-path: 'true'
138
spec:
139
  parentRefs:
140
  - name: kong
141
    namespace: kic
142
  rules:
143
  - matches:
144
    - path:
145
        type: PathPrefix
146
        value: /test-server
147
    backendRefs:
148
    - name: test-server
149
      kind: Service
150
      port: 80
151
---
152
apiVersion: v1
153
kind: Service
154
metadata:
155
  name: test-server-externalname
156
  namespace: kic
157
spec:
158
  type: ExternalName
159
  externalName: test-server.kic.svc.80.mesh
160
---
161
apiVersion: gateway.networking.k8s.io/v1
162
kind: HTTPRoute
163
metadata:
164
  name: k8s-ingress-dot-mesh
165
  namespace: kic
166
  annotations:
167
    konghq.com/strip-path: 'true'
168
spec:
169
  parentRefs:
170
  - name: kong
171
    namespace: kic
172
  rules:
173
  - matches:
174
    - path:
175
        type: PathPrefix
176
        value: /dot-mesh
177
    backendRefs:
178
    - name: test-server-externalname
179
      kind: Service
180
      port: 80
181
`
182

183
		Expect(kubernetes.Cluster.Install(YamlK8s(ingressMeshDNS))).To(Succeed())
184

185
		Eventually(func(g Gomega) {
186
			_, err := client.CollectEchoResponse(
187
				kubernetes.Cluster, "demo-client", fmt.Sprintf("http://%s/dot-mesh", kicIP),
188
				client.FromKubernetesPod(namespaceOutsideMesh, "demo-client"),
189
			)
190
			g.Expect(err).ToNot(HaveOccurred())
191
		}, "30s", "1s").Should(Succeed())
192
	})
193
}
194