Webinar Series: Getting Started with Kubernetes

To follow this tutorial, you will need

• A local machine with the curl command installed, which you’ll use to download a command-line tool to manage your Kubernetes cluster. The curl command is already installed on macOS and Ubuntu 16.04.
• A DigitalOcean account. In this tutorial, you’ll use StackPoint to connect to your DigitalOcean account and provision three 1GB Droplets.

To start the installation of Kubernetes on DigitalOcean, visit Stackpoint.io and click on the Login button.

This takes you to a page where you can choose an identity provider and log in with existing credentials. Choose DigitalOcean from the list and log in with your DigitalOcean username and password.

On the next page, choose DigitalOcean from the list of available cloud platforms.

You can now configure the cluster. Click on the EDIT button to edit the settings for the DigitalOcean provider:

This takes you to the Configure Provider screen.

Choose a region of your choice from the Region dropdown list. You can leave the other settings at their default values. Click on Submit when you are done.

On the next screen, enter a cluster name of your choice and click Submit.

The cluster installation will now start and you’ll be taken to a page where you can track the cluster’s progress. The installation will take about 15 minutes.

Once the cluster is configured, we can set up a command-line tool to work with it.

To talk to the Kubernetes cluster running in DigitalOcean, we need a command line tool in our development machine. We’ll use kubectl, the CLI for Kubernetes.

Run the following commands to install kubectl from Google’s servers:

curl -LO https://storage.googleapis.com/kubernetes-release/release/`curl -s https://storage.googleapis.com/kubernetes-release/release/stable.txt`/bin/darwin/amd64/kubectl

You’ll see this output:

Output
 % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                Dload  Upload   Total   Spent    Left  Speed

100 63.7M  100 63.7M    0     0  5441k      0  0:00:12  0:00:12 --:--:-- 4644k

The kubectl binary was downloaded to your current directory, Let’s change the permissions of the downloaded binary and move it to the /usr/local/bin directory so we can run it from anywhere:

chmod +x ./kubectl
sudo mv ./kubectl /usr/local/bin/kubectl

Now let’s point the kubectl app at our Kubernetes cluster. For that, we need to download a configuration file from Stackpoint. Return to the cluster status page in your browser. After verifying that the cluster is ready and stable, click on the cluster name as shown in the following figure:

Click on the kubeconfig link in the left-hand menu to download the configuration file to your local machine:

Back in your terminal, set the environment variable KUBECONFIG to the path of the downloaded file. Assuming your file downloaded to the Downloads folder in your home directory, you’d issue this command:

export KUBECONFIG=~/Downloads/kubeconfig

With kubectl configured, let’s make sure we can communicate with our cluster.

Now that we have the fully configured cluster along with the client, let’s run a few commands to verify the environment.

Run the following command to get information about the cluster.

kubectl cluster-info

You’ll see this output:

Output
Kubernetes master is running at https://139.59.17.180:6443

Heapster is running at https://139.59.17.180:6443/api/v1/namespaces/kube-system/services/heapster/proxy

KubeDNS is running at https://139.59.17.180:6443/api/v1/namespaces/kube-system/services/kube-dns/proxy

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.

The output confirms that the cluster is working and that the Kubernetes Master Nodes are up and running.

Next, let’s verify the health of all the components running in the Master Nodes. If the cluster is just configured, it may take a while before all the components show a healthy status. These components are a part of the Kubernetes Master Nodes that act as the control plane.

Execute this command:

kubectl get cs

You’ll see this output:

Output
NAME                 STATUS    MESSAGE              ERROR
scheduler            Healthy   ok
controller-manager   Healthy   ok
etcd-0               Healthy   {"health": "true"}

Finally, let’s list all the nodes of the running Kubernetes cluster.

kubectl get nodes

You’ll see output like this:

Output
NAME                  STATUS    ROLES     AGE       VERSION
spc52y2mk3-master-1   Ready     master    29m       v1.8.5
spc52y2mk3-worker-1   Ready     <none>    22m       v1.8.5
spc52y2mk3-worker-2   Ready     <none>    22m       v1.8.5

This confirms that the cluster with one Master Node and two Worker Nodes is ready for us to deploy applications. So let’s deploy an application to the cluster.

Let’s launch a simple Nginx web server and access its default web page from our local machine. Execute this command to pull the Nginx image from Docker Hub and create a deployment called myweb:

kubectl run --image=nginx:latest myweb

This command is similar to the docker run command, except that it packages and deploys the container in a Kubernetes-specific artifact called a Pod. You’ll learn more about Pods in the next part of this series.

When you execute the command, you’ll see this output:

Output
deployment "myweb" created

Now check that the Pod is created with the nginx container:

kubectl get pods

You’ll see this output:

Output
NAME                     READY     STATUS    RESTARTS   AGE
myweb-59d7488cb9-jvnwn   1/1       Running   0          3m

To access the web server running inside the Pod, we need to expose it to the public Internet. We achieve that with the following command:

kubectl expose pod myweb-59d7488cb9-jvnwn --port=80 --target-port=80 --type=NodePort

Output
service "myweb-59d7488cb9-jvnwn" exposed

The Pod is now exposed on every Node of the cluster on an arbitrary port. The --port and --target-port switches indicate the ports through which the web server becomes available. The switch --NodePort ensures that we can use any Node on the cluster to access the application.

To get the NodePort of the myweb deployment, run the following command.

kubectl get svc myweb-59d7488cb9-jvnwn

Output
NAME                     TYPE       CLUSTER-IP   EXTERNAL-IP   PORT(S)        AGE
myweb-59d7488cb9-jvnwn   NodePort   10.3.0.119   <none>        80:31930/TCP   6m

In this case, the NodePort is port 31930. Every Worker Node uses this port to respond to HTTP requests. Let’s test it out.

Use the DigitalOcean Console to get the IP address of one of the Worker Nodes.

Use the curl command to make an HTTP request to one of the nodes on port 31930.

curl http://your_worker_1_ip_address:31930/

You’ll see the response containing the Nginx default home page:

Output
<!DOCTYPE html>
<html>
  <head>
    <title>Welcome to nginx!</title>
...
     Commercial support is available at
     <a href="http://nginx.com/">nginx.com</a>.</p>
    <p><em>Thank you for using nginx.</em></p>
  </body>
</html>

You have successfully deployed a containerized application to your Kubernetes cluster.

Kubernetes is a popular container management platform. StackPoint makes it easy to install Kubernetes on DigitalOcean.

In the next part of this series, we will explore the building blocks of Kubernetes in more detail.