TIR Kubernetes

TIR Kubernetes gives you a managed Kubernetes cluster in a TIR project. E2E sets up and runs the control plane. You choose the Kubernetes version, the size and plan of the control plane, one or more worker pools, and the VPC the nodes sit in. From there you work with the cluster through its kubeconfig and kubectl, and deploy to it with manifests or Helm, as you would on any Kubernetes cluster.

The cluster’s nodes run as virtual machines in your VPC and take their addresses from its subnet, so the cluster sits on your private network beside your other TIR resources.

Worker capacity comes in worker pools. Each pool has its own plan and its own number of nodes, and you can add, resize, autoscale, and delete pools while the cluster runs. You can also give a pool node labels and taints, so that pods land on the nodes meant for them.

Every cluster also comes with:

• Cilium for pod and service networking. The platform sets it up and manages it, along with the other add-ons it installs.
• A default StorageClass on Ceph block storage, so a volume claim works straight away.
• An LB IP pool, which holds the reserved public IPs that your Services of type LoadBalancer take their addresses from.
• Built-in monitoring of every node’s CPU, memory, disk, and network.

Kubernetes works with three other TIR products:

• VPC for the network the nodes sit on.
• Reserve IP for LoadBalancer addresses.
• Container Registry for your private images.

Where to find it

In TIR, open your project. In the side menu, under PRODUCTS, select Kubernetes. Your clusters are listed in Manage Kubernetes Cluster. Select a cluster’s name to open its details, where the Overview, Monitoring, Node Pool, and LB IP Pool tabs hold everything about that cluster.

How it fits together

Diagram as text

flowchart LR
    V[Your VPC] --> C[Cluster]
    CP[Control plane, run by E2E] --> C
    W[Worker pools] --> C
    R[Reserved IPs] --> L[LB IP Pool] --> C
    C --> K[kubeconfig]
    K --> T[kubectl and Helm]

You pick a VPC, a control plane, and at least one worker pool, and TIR builds the cluster from them. Once it is ready, you download its kubeconfig and point kubectl at it. To publish a Service on a public address, attach reserved IPs to the cluster’s LB IP pool. Each Service of type LoadBalancer then takes one of them.

What you can do

Create and connect

• Create a Kubernetes cluster, with every choice on the form explained.
• Connect to a Kubernetes cluster with the kubeconfig and kubectl, for one shell or permanently.

Worker pools

• Add and delete worker pools on a running cluster.
• Resize or autoscale a worker pool to a fixed size, or between a minimum and a maximum on CPU or memory use.
• Set node labels and taints to steer pods to the right pool.
• Manage committed plans: move a pool to a committed plan, and choose what happens when its term ends.

Workloads

• Expose services with a load balancer on reserved IPs.
• Set up an ingress controller with HTTPS, which routes requests for many sites through one address by hostname.
• Use persistent volumes, which keep their data after a pod restarts.
• Pull images from Container Registry with a pull secret.

Monitor and delete

• Monitor a Kubernetes cluster: node health, CPU, memory, disk, and network.
• Delete a Kubernetes cluster when you have finished with it.

You can also manage clusters, worker pools, and LoadBalancer IPs through the API; see Kubernetes in the TIR API.

Where to start

Start with Get started with TIR Kubernetes, which walks you through creating a small cluster and running a first kubectl command against it. To understand the control plane, worker pools, networking, and cluster statuses before you build, read How a TIR Kubernetes cluster works. For how pools are billed, see Billing options for TIR Kubernetes. For help with a problem, see Troubleshooting TIR Kubernetes, and for short answers, the TIR Kubernetes FAQ.