Skip to content

Taikun - Your Kubernetes Engineer

How to go from Zero to Production with Kubernetes in under 30 mins

Kubernetes has become one of the most critical aspects of any Cloud infrastructure. With such ubiquitousness of Kubernetes, having the ability to create and deploy Kubernetes clusters quickly has become a very important function in the cloud workflow.

In the previous blog, we showed you how Taikun could be used to manage your Kubernetes infrastructure efficiently. In this blog, we will show you two ways in which you can use Taikun and go from Zero to production with Kubernetes in under 30 minutes.

We first need to understand some of the concepts in Taikun.

Understanding some Taikun concepts

Organization and Projects

In Taikun, an Organization is the highest level of grouping. There can be many Projects under an Organization. You can add many features to an Organization that gets inherited in the Projects under that Organization.

For example, you can add Access profiles, Alerting profiles, Kubernetes profiles etc.

User roles

Taikun has three user roles – User, Manager and Partner.

A Partner role is the one with the most administrative privileges. A Partner can create multiple organisations and has the ability to create other features for an organisation.

A Manager role has administrative privileges over projects under an organisation. A user role in Taikun is mostly for execution.

Zero to Production in 30 mins

With those Taikun concepts in mind, let’s see how we can get a Production-grade Kubernetes cluster in 30 mins.

There are essentially two methods in which you can deploy your Kubernetes infrastructure quickly in Taikun - UI method and Terraform methods.

UI method

You need to be of a Manager or Partner role to execute most of the below activities.

Step 1: Login To Taikun and connect your cloud

The first step towards creating your own Kubernetes cluster using Taikun is to create a login in Taikun. You can also use Keycloak if it is set within your organization.

After you login to the Taikun dashboard, you have to first authorise Taikun to access your cloud infrastructure. This is done by adding Cloud credentials to the Taikun Dashboard.

Taikun can currently link to your Open Stack, AWS and Azure and Google Cloud setups. Detailed steps on how to connect to these cloud infrastructures are given in Taikun Documentation.

Once you have linked your cloud infrastructure to Taikun, the next step is to start creating profiles for the Organization.

Step 2: Create profiles

Before creating a project, you need to have the profiles that you would like the project to inherit.

Create the Kubernetes profiles, Access profiles and Alerting profiles that you would need in different projects of the Organization. Later while creating the projects, we would link these profiles to them.

Kubernetes profiles basically define the characteristics of your cluster. You can read all about Kubernetes profiles in the Taikun Documentation.

Access profiles are needed to connect to the clusters offline. Access profiles are described in the Taikun Documentation.

Alerting profiles help you receive notifications when there is an alert in your project. Read more about Alerting profiles in the Taikun Documentation.

Step 3: Create a project

Now you are ready to create your Kubernetes infrastructure. The first step is to create a Project that will hold all the clusters.

Go to Projects under the User section and click on “Add project” button in the top right corner. Add the info and link the profiles as per your requirements.

You also attach flavors that are allowed to be created within the project. For eg., you may feel, as a Manager or Partner, that the project only needs an n0.medium or an n0.xsmall flavor. Finally, you need to attach users to the project. Only these users will be able to operate on this project.

The detailed steps are there in the Taikun Documentation.

Step 4: Creating a Cluster

As you would know, a working Kubernetes cluster requires at least 1 Bastion, 2 Kubemaster and 1 Kubeworker. Any user/manager/partner associated with the project can now create these servers.

Start adding the servers you need by clicking the “Add Server” button on the top-right corner. Once you have created the entire cluster, go to the Actions drop-down menu and click commit.

Once the servers are live, a status in Green will show the text “Ready” under the server status. Taikun Documentation share more details on it.

Step 5: Configuring a project

The last step is to configure the cluster to manage it remotely.

Go to Projects and click on Kubeconfig to define the configuration for the project clusters.

There are also other options to manage projects better. For eg, you can setup automatic backup feature for your clusters. Enabling monitoring will help you debug your clusters better and you can also lock (or unlock) access to different projects if needed.

All details on configuring your infrastructure is here.

And that’s it! In 30 mins or less, you can build a production-grade Kubernetes infrastructure just by using the Taikun dashboard. Let us now see the other way to do the same.

This time, using an infrastructure-as-a-code tool, Terraform.

Terraform method

Terraform lets you define Kubernetes resources in human-readable configuration files (.tf files). Taikun has a Terraform provider that helps you manage resources in Taikun using Terraform. The complete documentation on Taikun’s Terraform Provider is on Terraform registry docs.

Step 1: Setup your environment

You need to have Terraform, Git and Docker set up to run the config files. As you would know, in Terraform all the infrastructure is written as human-readable configuration files in a folder.

The, as is the convention, contains the Provider configuration.

terraform {
  required_providers {
    taikun = {
      source = "itera-io/taikun"
      version = "1.2.0"

provider "taikun" {
  email    = var.taikun_email
  passwoed = var.taikun_password

The init command will initialise Terraform for the infrastructure code.

terraform init 

Let’s see how the infrastructure config files would look.

Step 2: Create Organisation

The config code for an Organisation is straightforward. Just put this in any .tf file:

resources "taikun_organization" "myorg" {
  name          = "<name>"
  full_name     = "<full-name>"
  discount_rate = 120

The below command will create the organisation “name” with the label “myorg”.

terraform apply

Step 3: Create Profiles

Profiles like Kubernetes profile, Access profile and Alerting profile can then be defined.

A sample config for setting Kubernetes profile would look as follows:

resource "taikun_kubernetes_profile" "foo" {
  name = "foo"

  organization_id         = "42"
  load_balancing_solution = "Taikun"
  bastion_proxy           = true
  schedule_on_master      = false
  lock                    = true
The schema for the Kubernetes profile and other profiles are given in the Terraform registry docs.

Step 4: Create Users

To create users, the variables are first defined in a .tf file and then the variables are defined in a .tfvars file.

For example, you could create a to define the access details of a user. It could look something like this:

variable "user" {
  type = map(object({
    email = string
    role  = string
  description = "List of project users"
  default      {}
Then another file called tfvars file can be used to declare the users. A sample code for users Alice and Bob would look like this:

users = {
  "alice" = {
    email = ""
    role  = "Manager"
  "bob" = {
    email = ""
    role  = "User"

You can read more about schema for taikun_access_profile here.

Step 4: Create the infrastructure

To create a project resource, you would need to start with declaring the flavors that will bound to the project.

That is done by declaring a flavor data source as follows:

data "taikun_flavors" "small" {
  cloud_credential_id =
  min_cpu             = 2
  max_cpu             = 8

Then use a local value called flavors to point to the list of flavors in the above data source.

locals {
  flavors = [for flavor in data.taikun_flavors.small.flavors :]

Now the ground is set to declare a Kubernetes project and spin the clusters.

resource "taikun_project" "foobar" {
  name                = "foobar"
  cloud_credential_id =

  access_profile_id     =
  alerting_profile_id   =
  kubernetes_profile_id =
  policy_profile_id     =

  expiration_date = "21/12/2012"
  auto_upgrade    = true
  monitoring      = true

  quota_cpu_units = 64
  quota_disk_size = 1024
  quota_ram_size  = 256

  flavors = local.flavors

  vm {
    name        = "b"
    volume_size = 30

    flavor   = local.flavors[0]

    cloud_init            = ""
    standalone_profile_id =
    public_ip             = true

    volume_type = "ssd-2000iops"

    tag {
      key   = "key"
      value = "value"

    disk {
      name        = "name"
      size        = 30
      volume_type = "ssd-2000iops"


  server_bastion {
    name   = "b"
    flavor = local.flavors[0]
  server_kubemaster {
    name   = "m"
    flavor = local.flavors[0]
  server_kubeworker {
    name      = "w"
    flavor    = local.flavors[0]
    disk_size = 30

That’s it. The “terraform apply” command will apply the config and create the clusters. You can read more about creating projects using Taikun’s Terraform Provider here.

The detailed documentation for this method with live example code can be accessed here.

Taikun - Your Kubernetes Engineer

The ability to quickly create and deploy and manage Kubernetes clusters has been a huge shot in the arm for cloud management.

As you see with Taikun, your focus shifts from “How to create” to “What to create” when it comes to Kubernetes clusters. Taikun, truly, is your Kubernetes Engineer.

Please contact us to explore Taikun in more detail and for a free consultation.

If you wish to try Taikun and see it in action, try our cloud solution here.

Back to top