Kubernetes
Managed Kubernetes clusters: we run the control plane and it is free, the nodes are servers in your project.
How it is built
- The control plane (the Kubernetes API, etcd and the rest) runs on our side, managed by us. It is free.
- The nodes are virtual machines in your project: they are charged like servers and count towards the project's quota, but they do not appear among your servers.
- Nodes join the cluster on their own, within a few minutes. Nobody logs into the nodes: the cluster is used with
kubectland its kubeconfig. - Nodes are grouped into node pools: each pool has its own size, number of nodes, disk and, if you like, one public address per node.
- Nodes must be able to get out to the internet: through the project's NAT gateway, if there is one, or with one public address per node (Egress in the panel: Nodes without a public address go out through the project NAT gateway: without one, give them a public address).
Kubernetes is available where the zone offers it: if the Kubernetes section does not appear on the Cloud page, your zone does not have it today.
The cluster address
Every new cluster gets a name of three words in its zone, for example amber-falcon-river.gk01.ch: the API is https://amber-falcon-river.gk01.ch:6443. The name is published in DNS as soon as the cluster exists and disappears with it; it is in the API server certificate, so kubectl checks it as with any other server. All clusters of a zone share one address and are told apart by name, which is why the control plane is free. If you need an address of your own (dedicated endpoint, for example to filter it on your firewall), ask for it when you create the cluster with endpoint: dedicated.
What is inside, and what is not yet
- Pod network: every cluster is born with one (Flannel, VXLAN between the nodes). You do not install anything to get nodes Ready.
- DNS inside the cluster (CoreDNS) and kube-proxy: included.
kubectl logs,exec,port-forward: they work through a tunnel from the control plane to the nodes; give a new node a few seconds after it becomes Ready.- Services of type
LoadBalancer: supported. Create one as usual (kubectl expose deployment web --type=LoadBalancer --port=80): within a minute it gets a public IPv4 address inEXTERNAL-IP, routed to two of your nodes on different servers, and the service's ports are opened on those nodes (only fromloadBalancerSourceRanges, if you set them). The address is one of the project's public addresses: it counts in the quota and is charged like the others, and it is released when you delete the service. It needs nodes with a public address. PreferexternalTrafficPolicy: Cluster(the default). Services with aloadBalancerClassare left to your own controller. - Persistent volumes: the default
StorageClassislocal-path: aPersistentVolumeClaimgets a directory on the disk of the node where its pod runs, and the pod stays on that node. Keep data you cannot lose replicated by your application, or backed up. kubectl top: included (metrics-server).
Creating a cluster
In Cloud, Normal mode, Kubernetes section, press New Kubernetes cluster:
- Name: lowercase letters, digits and hyphens, starting with a letter, 2 to 20 characters.
- Version: the Kubernetes version, among those the zone offers.
- Node pools: for each pool - Pool: the name, a lowercase letter followed by letters and digits, up to 8 characters, different for each pool; - Size: the size of each node; - Nodes: how many nodes (0 is allowed); - Disk GB: each node's disk (at least 10, usually 40); - Public IP: a public IPv4 address for each node.
Add a pool adds a pool (up to 10). 4. Review the plan, then Create cluster.
The cluster goes from Creating to Ready. In the list you see the state, the version, the API address (endpoint) and how many nodes are ready out of how many were requested (… / … nodes ready). Next to it is the reminder Control plane free.
Managing a cluster
Open the cluster from the list:
- Node pools: change the number of nodes in a pool and press Apply. If the number goes down, nodes are removed starting from the highest number, together with whatever runs on them. A new size or disk only applies to new nodes;
- Add a pool: one more pool;
- Remove pool: removes a pool with all its nodes; to confirm, type the pool's name again. There is no undo;
- Nodes: the nodes, with their pool, state and addresses;
- Download kubeconfig: downloads the file
<name>.kubeconfig(see below); - Delete: deletes the cluster, that is the control plane with all the cluster's data and all the nodes. To confirm, type the name again, then Delete for good.
The kubeconfig
The kubeconfig is the file kubectl uses to get into the cluster. It is a credential with full rights on the cluster: treat it like a password (Full rights on the cluster: keep it like a password).
- Only Can manage and the project owner can download it, once the cluster is ready.
- Every read is recorded in the project's log.
- The AI mode assistant does not give it to you: you download it from the panel.
- An API key that requires approval cannot read it.
To use it:
export KUBECONFIG=$PWD/<name>.kubeconfig
kubectl get nodes
For developers
| What | Method | MCP tool | Role |
|---|---|---|---|
| Available versions | Cloud/getCatalog (kubernetes_versions) |
cloud_get_catalog |
viewer |
| List | Cloud/getKubernetesClusterList |
cloud_get_kubernetes_cluster_list |
viewer |
| Details with nodes | Cloud/getKubernetesCluster (cluster_id) |
cloud_get_kubernetes_cluster |
viewer |
| Create | Cloud/createKubernetesCluster |
cloud_create_kubernetes_cluster |
operator |
| Add or resize a pool | Cloud/setKubernetesNodePool (cluster_id, pool, size, count, disk_gb?, public_ip?) |
cloud_set_kubernetes_node_pool |
operator |
| Remove a pool | Cloud/deleteKubernetesNodePool (cluster_id, pool) |
cloud_delete_kubernetes_node_pool |
operator |
| Delete | Cloud/deleteKubernetesCluster (cluster_id) |
cloud_delete_kubernetes_cluster |
operator |
| Kubeconfig | Cloud/getKubernetesKubeconfig (cluster_id) |
cloud_get_kubernetes_kubeconfig |
admin |
Cloud/createKubernetesCluster accepts endpoint (shared, the default, or dedicated) and two forms for the nodes:
- a single pool:
name,version?,node_size,node_count,node_disk_gb? (40),node_public_ip? (false). The pool is calledworkers; - several pools:
name,version?,node_pools: a list (up to 10) of{name, size, count, disk_gb?, public_ip?}objects.
Not both at once. It also accepts idempotency_key and dry_run.
# a cluster with three s-2-4 nodes
curl -s https://gigakube.ch/api/rpc \
-H "Authorization: Bearer $GIGAKUBE_API_KEY" -H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"Cloud/createKubernetesCluster","params":{"call_data":{"name":"prod","node_size":"s-2-4","node_count":3}}}'
# the kubeconfig, once it is ready (needs a key with the admin role)
curl -s https://gigakube.ch/api/rpc \
-H "Authorization: Bearer $GIGAKUBE_API_KEY" -H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"Cloud/getKubernetesKubeconfig","params":{"call_data":{"cluster_id":"<id>"}}}' \
| jq -r '.result.call_data.kubeconfig' > prod.kubeconfig
A cluster has id, name, status (creating, ready, error, deleting), version, endpoint, endpoint_type (shared or dedicated), nodes_wanted, nodes_ready, node_pools, message. Before it is ready, the kubeconfig request answers with a conflict (The cluster is not ready yet).