Take DigitalOcean Kubernetes for a Cruise
DigitalOcean is one of the recent public cloud providers to jump the managed Kubernetes bandwagon. Given its simplicity and minimalistic approach to managing infrastructure, it’s not surprising to see DigitalOcean following the same philosophy for its Containers as a Service (CaaS) offering.
In this tutorial, we will take a look at the workflow involved in launching a DigitalOcean Kubernetes cluster and deploying workloads on it.
Launching the Kubernetes Cluster
At present, DigitalOcean offers two versions of Kubernetes — 1.12 and 1.13. The service is currently in limited availability which means it may not be available in all the regions and is not production-ready.
Let’s go ahead and launch a three-node cluster through the DigitalOcean Control Panel.
It all starts with the selection of a specific Kubernetes version followed by the region.
The next step is to create a node pool with droplets that act as worker nodes. DigitalOcean offers three classes of nodes — standard, flexible, and CPU optimized. Standard nodes are the generic droplets offering basic to advanced configuration. Flexible droplets have a flat fee but the amount of memory and number of CPU cores vary with each configuration. CPU optimized are meant for running compute-intensive workloads that demand beefy VMs.
If your deployment demands a combination of these droplets, you can create separate node pools for each configuration and add them later. Each node pool can be selectively used with a specific workload.
Finally, give a name to your cluster and push the button.
The same can be launched with the nifty doctl CLI with the below command:
|
1 2 3 4 5 |
doctl kubernetes cluster create do-tide \ --region blr1 \ --version 1.13.5-do.0 \ --tag demo \ --node-pool "name=pool1;size=s-1vcpu-2gb;count=3" |
Once the cluster is up and running, download the kubeconfig file and point it to the kubectl tool.
|
1 |
doctl kubernetes cluster kubeconfig save do-tide |
This command puts the configuration file in the ~/.kube/config directory.
Verify the cluster by running a couple of standard kubectl commands.
Deploying and Scaling a Workload
With the cluster in place, let’s go ahead and deploy a MEAN web application. The MongoDB Pod will be backed by a block storage volume for persistence. The stateless web application is deployed as a Replica Set that can be scaled in and scaled out.
DigitalOcean Kubernetes comes with its own storage class for the block storage. We will use that to create a Persistent Volume Control (PVC).
Create the PVC pointing to the storage class.
|
1 2 3 4 5 6 7 8 9 10 11 |
apiVersion: v1 kind: PersistentVolumeClaim metadata: name: mongo-pvc spec: accessModes: - ReadWriteOnce resources: requests: storage: 5Gi storageClassName: do-block-storage |
Launch the MongoDB Pod with the below definition. Notice that the PVC is pointed to mongo-pvc created in the previous step.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
apiVersion: v1 kind: Pod metadata: name: db labels: name: mongo app: todoapp spec: containers: - image: mongo name: mongo ports: - name: mongo containerPort: 27017 hostPort: 27017 volumeMounts: - name: mongo-storage mountPath: /data/db volumes: - name: mongo-storage persistentVolumeClaim: claimName: mongo-pvc |
Expose the MongoDB Pod through a ClusterIP service.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
apiVersion: v1 kind: Service metadata: name: db labels: name: mongo app: todoapp spec: selector: name: mongo type: ClusterIP ports: - name: db port: 27017 targetPort: 27017 |
Now, let’s deploy the web app built with Node.js. The Deployment has three replicas.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
apiVersion: apps/v1 kind: Deployment metadata: name: web labels: name: web app: todoapp spec: replicas: 3 selector: matchLabels: name: web template: metadata: labels: name: web spec: containers: - name: web image: janakiramm/todo ports: - containerPort: 3000 |
To access the web app, we will expose it through an external load balancer.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
apiVersion: v1 kind: Service metadata: name: web labels: name: web app: todoapp spec: selector: name: web type: LoadBalancer ports: - name: http port: 80 targetPort: 3000 protocol: TCP |
We now have one Pod of MongoDB and three Pods running the web application exposed through a ClusterIP and LoadBalancer respectively.
The external IP corresponds to a DigitalOcean Load Balancer created dynamically by Kubernetes. You can verify this by accessing the load balancers under the Network section of the control panel.
DigitalOcean has done a great job with the integration of its core infrastructure with Kubernetes. The storage class for block storage and load balancer integration make it extremely simple to deploy and manage both stateful and stateless workloads.
Janakiram MSV’s Webinar series, “Machine Intelligence and Modern Infrastructure (MI2)” offers informative and insightful sessions covering cutting-edge technologies. Sign up for the upcoming MI2 webinar to learn how to use Azure IoT Edge.