Kubernetes and the router

Using router images with kubernetes

Sample Kubernetes Configuration

Note: The Apollo Router is made available under the Elastic License v2.0 (ELv2). This applies to its source code and all distributions, including versions installed via Helm charts. Read our licensing page for more details.

Helm

Helm is the package manager for kubernetes.

There is a complete helm chart definition in the repo which illustrates how to use helm to deploy the router in kubernetes.

In both the following examples, we are using helm to install the router:

into namespace "router-deploy" (create namespace if it doesn't exist)
with helm install name "router-test"
with support for prometheus enabled

Using helm chart from our Open Container Initiative (OCI) registry

Starting with release 0.14.0, each time we release the router, we'll release our helm chart and store it in the same OCI registry in which we store our router docker images.

You can use helm to install charts from an OCI registry as follows:

1
helm install --set router.configuration.telemetry.metrics.prometheus.enabled=true --set managedFederation.apiKey="REDACTED" --set managedFederation.graphRef="REDACTED" --create-namespace --namespace router-deploy router-test oci://ghcr.io/apollographql/helm-charts/router --version 1.0.0-rc.8 --values router/values.yaml

For more details about using helm with OCI based registries, see here

Using helm chart from your filesystem

You would run this command from "repo"/helm/chart directory.

(where "repo" is the directory containing your checked out router github repository)

1
helm install --set router.configuration.telemetry.metrics.prometheus.enabled=true --set managedFederation.apiKey="REDACTED" --set managedFederation.graphRef="REDACTED" --create-namespace --namespace router-deploy router-test router --values router/values.yaml

Once executed, you can check the status of the helm deploy:

1
helm list --namespace router-deploy

Kubernetes Configuration

If you aren't familiar with helm, the following example illustrates how you could do the same thing manually or as a base for kustomize.

Note: This example is generated using the helm template capability to generate the required kubernetes configuration from our helm chart. After generation, it is edited to remove the Helm management annotations.

1
---
2
# Source: router/templates/serviceaccount.yaml
3
apiVersion: v1
4
kind: ServiceAccount
5
metadata:
6
  name: release-name-router
7
  labels:
8
    helm.sh/chart: router-1.20.0
9
    app.kubernetes.io/name: router
10
    app.kubernetes.io/instance: release-name
11
    app.kubernetes.io/version: "v1.20.0"
12
    app.kubernetes.io/managed-by: Helm
13
---
14
# Source: router/templates/secret.yaml
15
apiVersion: v1
16
kind: Secret
17
metadata:
18
  name: "release-name-router"
19
  labels:
20
    helm.sh/chart: router-1.20.0
21
    app.kubernetes.io/name: router
22
    app.kubernetes.io/instance: release-name
23
    app.kubernetes.io/version: "v1.20.0"
24
    app.kubernetes.io/managed-by: Helm
25
data:
26
  managedFederationApiKey: "UkVEQUNURUQ="
27
---
28
# Source: router/templates/configmap.yaml
29
apiVersion: v1
30
kind: ConfigMap
31
metadata:
32
  name: release-name-router
33
  labels:
34
    helm.sh/chart: router-1.20.0
35
    app.kubernetes.io/name: router
36
    app.kubernetes.io/instance: release-name
37
    app.kubernetes.io/version: "v1.20.0"
38
    app.kubernetes.io/managed-by: Helm
39
data:
40
  configuration.yaml: |
41
    health_check:
42
      listen: 0.0.0.0:8088
43
    supergraph:
44
      listen: 0.0.0.0:80
45
    telemetry:
46
      metrics:
47
        common:
48
          resources:
49
            service.name: release-name-router
50
        prometheus:
51
          enabled: true
52
          listen: 0.0.0.0:9090
53
          path: /metrics
54
---
55
# Source: router/templates/service.yaml
56
apiVersion: v1
57
kind: Service
58
metadata:
59
  name: release-name-router
60
  labels:
61
    helm.sh/chart: router-1.20.0
62
    app.kubernetes.io/name: router
63
    app.kubernetes.io/instance: release-name
64
    app.kubernetes.io/version: "v1.20.0"
65
    app.kubernetes.io/managed-by: Helm
66
spec:
67
  type: ClusterIP
68
  ports:
69
    - port: 80
70
      targetPort: http
71
      protocol: TCP
72
      name: http
73
    - port: 8088
74
      targetPort: health
75
      protocol: TCP
76
      name: health
77
  selector:
78
    app.kubernetes.io/name: router
79
    app.kubernetes.io/instance: release-name
80
---
81
# Source: router/templates/deployment.yaml
82
apiVersion: apps/v1
83
kind: Deployment
84
metadata:
85
  name: release-name-router
86
  labels:
87
    helm.sh/chart: router-1.20.0
88
    app.kubernetes.io/name: router
89
    app.kubernetes.io/instance: release-name
90
    app.kubernetes.io/version: "v1.20.0"
91
    app.kubernetes.io/managed-by: Helm
92
  
93
  annotations:
94
    prometheus.io/path: /metrics
95
    prometheus.io/port: "9090"
96
    prometheus.io/scrape: "true"
97
spec:
98
  replicas: 1
99
  selector:
100
    matchLabels:
101
      app.kubernetes.io/name: router
102
      app.kubernetes.io/instance: release-name
103
  template:
104
    metadata:
105
      labels:
106
        app.kubernetes.io/name: router
107
        app.kubernetes.io/instance: release-name
108
    spec:
109
      serviceAccountName: release-name-router
110
      securityContext:
111
        {}
112
      containers:
113
        - name: router
114
          securityContext:
115
            {}
116
          image: "ghcr.io/apollographql/router:v1.20.0"
117
          imagePullPolicy: IfNotPresent
118
          args:
119
            - --hot-reload
120
            - --config
121
            - /app/configuration.yaml
122
          env:
123
            - name: APOLLO_KEY
124
              valueFrom:
125
                secretKeyRef:
126
                  name: "release-name-router"
127
                  key: managedFederationApiKey
128
                  optional: true
129
            - name: APOLLO_GRAPH_REF
130
              value: REDACTED
131
          ports:
132
            - name: http
133
              containerPort: 80
134
              protocol: TCP
135
            - name: health
136
              containerPort: 8088
137
              protocol: TCP
138

139
          livenessProbe:
140
            httpGet:
141
              path: "/health"
142
              port: 8088
143
            initialDelaySeconds: 0
144
          readinessProbe:
145
            httpGet:
146
              path: "/health"
147
              port: 8088
148
            initialDelaySeconds: 0
149
          resources:
150
            {}
151
          volumeMounts:
152
            - name: router-configuration
153
              mountPath: /app/
154
              readOnly: true
155
      volumes:
156
        - name: router-configuration
157
          configMap:
158
            name: release-name-router
159
      terminationGracePeriodSeconds: 30
160
---
161
# Source: router/templates/tests/test-connection.yaml
162
apiVersion: v1
163
kind: Pod
164
metadata:
165
  name: "release-name-router-test-connection"
166
  labels:
167
    helm.sh/chart: router-1.20.0
168
    app.kubernetes.io/name: router
169
    app.kubernetes.io/instance: release-name
170
    app.kubernetes.io/version: "v1.20.0"
171
    app.kubernetes.io/managed-by: Helm
172
  annotations:
173
    "helm.sh/hook": test
174
spec:
175
  containers:
176
    - name: netcat
177
      image: busybox
178
      command: ['nc']
179
      args: ['-vz','-w','1','release-name-router:80']
180
  restartPolicy: Never

The health endpoint

The router supports a health endpoint. You can see from the examples above how it can be used in a kubernetes deployment.

If you had a router running on port 8088 on your localhost, you could exercise the health endpoint as follows:

1
curl "http://localhost:8088/health"
2
{"status":"UP"}

If you had a router running on your localhost, with default health-check configuration, you could exercise the health endpoint as follows:

curl "http://localhost:8088/health"

Docker

Build and run queries