Product Home > Kubernetes > How-Tos > Create Clusters

Was this page helpful?

How to Create Kubernetes Clusters

Validated on 12 Mar 2021 • Last edited on 15 Feb 2024 ha control plane | ha | load balancer | node pool

DigitalOcean Kubernetes (DOKS) is a managed Kubernetes service that lets you deploy Kubernetes clusters without the complexities of handling the control plane and containerized infrastructure. Clusters are compatible with standard Kubernetes toolchains, integrate natively with DigitalOcean Load Balancers and volumes, and can be managed programmatically using the API and command line. For critical workloads, add the high-availability control plane to increase uptime with 99.95% SLA.

Create a Cluster Using Automation

The API and CLI often require region, node size, and version values. You can retrieve a list of available option values using the /v2/kubernetes/options endpoint or the doctl kubernetes options command.

How to create a Kubernetes cluster using the DigitalOcean CLI

To create a Kubernetes cluster via the command-line, follow these steps:

Install doctl, the DigitalOcean command-line tool.
Create a personal access token, and save it for use with doctl.
Use the token to grant doctl access to your DigitalOcean account.
```
              doctl auth init
            
```
Finally, create a Kubernetes cluster with doctl kubernetes cluster create. The basic usage looks like this, but you'll want to read the usage docs for more details:
```
              doctl kubernetes cluster create <name> [flags]
            
```
The following example creates a cluster named example-cluster in the nyc1 region with a node pool, using Kubernetes version 1.28.2-do.0
```
               doctl kubernetes cluster create example-cluster --region nyc1 --version 1.28.2-do.0 --maintenance-window saturday=02
            
```

How to create a Kubernetes cluster using the DigitalOcean API

To create a Kubernetes cluster using the DigitalOcean API, follow these steps:

Create a personal access token, and save it for use with the API.

Send a POST request to https://api.digitalocean.com/v2/kubernetes/clusters

cURL

To create a Kubernetes cluster with cURL, call:


                curl -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $DIGITALOCEAN_TOKEN" \
  -d '{"name": "prod-cluster-01","region": "nyc1","version": "1.14.1\
  -do.4","tags": ["production","web-team"],"node_pools": [{"size": "s-1vcpu-2gb","count": 3,"name": "frontend-pool","tags": ["frontend"],"labels": {"service": "frontend", "priority": "high"}},{"size": "c-4","count": 2,"name": "backend-pool"}]}' \
  "https://api.digitalocean.com/v2/kubernetes/clusters"

Go

Go developers can use Godo, the official DigitalOcean V2 API client for Go. To create a Kubernetes cluster with Godo, use the following code:


                import (
    "context"
    "os"

    "github.com/digitalocean/godo"
)

func main() {
    token := os.Getenv("DIGITALOCEAN_TOKEN")

    client := godo.NewFromToken(token)
    ctx := context.TODO()

    createRequest := &godo.KubernetesClusterCreateRequest{
        Name:        "prod-cluster-01",
        RegionSlug:  "nyc1",
        VersionSlug: "1.14.1-do.4",
        Tags:        []string{"production", "web-team"},
        NodePools: []*godo.KubernetesNodePoolCreateRequest{
            &godo.KubernetesNodePoolCreateRequest{
                Name:  "frontend-pool",
                Size:  "s-2vcpu-2gb",
                Count: 3,
                Tags:  []string{"frontend"},
                Labels:  map[string]string{"service": "frontend", "priority": "high"},
            },
            &godo.KubernetesNodePoolCreateRequest{
                Name:  "backend-pool",
                Size:  "c-4",
                Count: 2,
            },
        },
    }

    cluster, _, err := client.Kubernetes.Create(ctx, createRequest)
}

Ruby

Ruby developers can use DropletKit, the official DigitalOcean V2 API client for Ruby. To create a Kubernetes cluster with DropletKit, use the following code:


                require 'droplet_kit'
token = ENV['DIGITALOCEAN_TOKEN']
client = DropletKit::Client.new(access_token: token)

cluster = DropletKit::KubernetesCluster.new(
  name: 'prod-cluster-01',
  region: 'nyc1',
  version: '1.14.1-do.4',
  tags: ['production', 'web-team'],
  node_pools: [
    {
      name: 'frontend-pool',
      size: 's-2vcpu-2gb',
      count: 3,
      tags: ['frontend'],
      labels: {service: 'frontend', priority: 'high'}
    },
    {
      name: 'backend-pool',
      size: 'c-4',
      count: 2
    }
  ]
)

client.kubernetes_clusters.create(cluster)

Python


                import os
from pydo import Client

client = Client(token=os.environ.get("DIGITALOCEAN_TOKEN"))

req = {
  "name": "prod-cluster-01",
  "region": "nyc1",
  "version": "1.18.6-do.0",
  "node_pools": [
    {
      "size": "s-1vcpu-2gb",
      "count": 3,
      "name": "worker-pool"
    }
  ]
}

resp = client.kubernetes.create_cluster(body=req)

Create a Cluster Using the Control Panel

You can create a DigitalOcean Kubernetes Cluster at any time from the DigitalOcean Control Panel by opening the Create menu in the top right.

In the Create menu, click Kubernetes to go to the Create a cluster page. On this page, you’ll choose a Kubernetes version, datacenter region, and cluster capacity for your cluster and then create it.

Select a Kubernetes version

The latest patch version for the three most recent minor versions of Kubernetes are available for new cluster creation. The latest stable release is selected by default.

Choose a datacenter region

Choose the region for your cluster. Your cluster’s control plane and worker nodes will be located in the same region.

If you plan to use volumes for persistent data storage, choose a region with volumes support. If you add a DigitalOcean Load Balancer to your deployment, it will automatically be placed in the same region as the cluster.

VPC Network

In the VPC Network section, choose a VPC network for the cluster. You can choose one you’ve created or use your default network for the datacenter region. VPC enables an additional networking interface that can only be accessed by other resources within the same VPC network. This keeps traffic between Droplets and other applicable resource from being routed outside the datacenter over the public internet.

Choose cluster capacity

A DOKS cluster has one or more node pools. Each node pool consists of a group of identical worker nodes. Worker nodes are built on Droplets.

To create a cluster, you need to specify the cluster’s scaling type and add at least one node pool with at least one worker.

Choose Fixed size or Autoscale for the scaling type and then specify the following fields for the node pool:

Node pool name: Choose a name for the node pool when it’s created. Nodes inside this pool inherit this naming scheme when they are created. If you rename the node pool later, the nodes will only inherit the new naming scheme when they are recreated (when you recycle the nodes or resize the node pool).
Machine type (Droplet): Choose if you want your worker nodes to be backed by Basic (Regular CPU, Premium Intel CPU, or Premium AMD CPU), General Purpose, CPU-Optimized (Regular Intel CPU or Premium Intel CPU), or Memory-Optimized Droplet plans. All machine types, except the Basic nodes, are dedicated CPU Droplets.

Choosing the right Kubernetes plan highly depends on your workload. See Choosing the Right Kubernetes Plan for more information.
Node plan: Choose the specific plan you want for your worker nodes. Each of the workers in a node pool has identical resources.

To take advantage of different resource capacities, you can add additional node pools with the Add Additional Node Pool button and assign pods to the node pools with the appropriate scheduling constraints.
Nodes: For a fixed-size cluster, choose how many nodes to include in the node pool. By default, three worker nodes are selected.
Minimum nodes and Maximum nodes: For an autoscaling-enabled cluster, choose the minimum and maximum number of nodes for when the load decreases or increases.

Note

One-node clusters are an inexpensive option to begin learning Kubernetes or for a development environment where resiliency isn’t a concern. However, a stand-alone Droplet with a container runtime or minikube will generally give you better performance than a one-node cluster for the same cost.

Select additional options

Then, you can optionally select the following settings.

Get extra reliability for critical workloads

DigitalOcean Kubernetes provides a high availability (HA) option that increases uptime and provides 99.95% SLA uptime for control planes. In the Get extra reliability for critical workloads section, select the Add high availability checkbox. Using this option creates multiple backup replicas of each control plane component and provides extra reliability for critical workloads.

Note

Once enabled, you cannot disable high availability.

Automate database management

To integrate your Kubernetes cluster with a DigitalOcean database, we recommend adding a free database operator during creation, now in beta. The database operator allows you to create new databases, automatically link them to your Kubernetes cluster, and manage them. For detailed information on using the operator, see our documentation on GitHub and how-to guide for diagrams.

While the operator is free, any databases you create with the operator are billed normally.

Finalize

Finalize the cluster settings. You can specify a name, assign a project, and optionally add tags to the cluster.

Name

By default, cluster names begin with k8s, followed by the version of Kubernetes, the datacenter region, and the cluster ID. You can customize the cluster name, which will also be used in the tag.

Project

The new cluster belongs to your default project. You can assign the cluster to a different project.

You can also change the project after you create the cluster. Go to the Kubernetes page in the control panel. From the cluster’s More menu, select Move to and select the project you want to move the cluster to.

Associated resources, such as load balancers and volumes, also move when you move the cluster to a different project.

Due to a known issue, resources associated with a DOKS cluster – such as load balancers, volumes, and volume snapshots – belong to the default project upon creation, regardless of which project the cluster belongs to. You can associate resources to the correct project by reconciling the cluster or moving the cluster to a different project.

Create Cluster

When you have entered your settings, create the cluster by clicking the Create Cluster button. It can take several minutes for cluster creation to finish.

Once your cluster is provisioned, you can view cluster information such as the cluster configuration, cost, cluster ID, and control plane high availability indicator in the Overview tab.

To manage the cluster, use kubectl, the official Kubernetes command-line client. See How to Connect to a DigitalOcean Kubernetes Cluster to get set up.

How to Create Kubernetes Clusters

Create a Cluster Using Automation

cURL

Go

Ruby

Python

Create a Cluster Using the Control Panel

Select a Kubernetes version

Choose a datacenter region

VPC Network

Choose cluster capacity

Select additional options

Get extra reliability for critical workloads

Automate database management

Finalize

Name

Project

Tags

Create Cluster

We can't find any results for your search.