website/docker.md at ea19c922fc7b89c33162d22c5a7968c15ede8f2d

5.7 KiB

Raw Blame History

The following instructions show you how to set up a simple, single node Kubernetes cluster using Docker.

Here's a diagram of what the final result will look like:

TOC {:toc}

Prerequisites

You need to have docker installed on one machine.
Decide what Kubernetes version to use. Set the ${K8S_VERSION} variable to a released version of Kubernetes >= "1.2.0"

Run it

docker run \
    --volume=/:/rootfs:ro \
    --volume=/sys:/sys:ro \
    --volume=/var/lib/docker/:/var/lib/docker:rw \
    --volume=/var/lib/kubelet/:/var/lib/kubelet:rw \
    --volume=/var/run:/var/run:rw \
    --net=host \
    --pid=host \
    --privileged=true \
    -d \
    gcr.io/google_containers/hyperkube-amd64:v${K8S_VERSION} \
    /hyperkube kubelet \
        --containerized \
        --hostname-override="127.0.0.1" \
        --address="0.0.0.0" \
        --api-servers=http://localhost:8080 \
        --config=/etc/kubernetes/manifests \
        --cluster-dns=10.0.0.10 \
        --cluster-domain=cluster.local \
        --allow-privileged=true --v=2

Note that --cluster-dns and --cluster-domain is used to deploy dns, feel free to discard them if dns is not needed.

If you would like to mount an external device as a volume, add --volume=/dev:/dev to the command above. It may however, cause some problems described in #18230

This actually runs the kubelet, which in turn runs a pod that contains the other master components.

Download `kubectl`

At this point you should have a running Kubernetes cluster. You can test this by downloading the kubectl binary for ${K8S_VERSION} (look at the URL in the following links) and make it available by editing your PATH environment variable. (OS X/amd64) (OS X/386) (linux/amd64) (linux/386) (linux/arm)

For example, OS X:

wget http://storage.googleapis.com/kubernetes-release/release/v${K8S_VERSION}/bin/darwin/amd64/kubectl
chmod 755 kubectl
PATH=$PATH:`pwd`

Linux:

wget http://storage.googleapis.com/kubernetes-release/release/v${K8S_VERSION}/bin/linux/amd64/kubectl
chmod 755 kubectl
PATH=$PATH:`pwd`

On OS X, to make the API server accessible locally, setup a ssh tunnel.

docker-machine ssh `docker-machine active` -N -L 8080:localhost:8080

Setting up a ssh tunnel is applicable to remote docker hosts as well.

(Optional) Create kubernetes cluster configuration:

kubectl config set-cluster test-doc --server=http://localhost:8080
kubectl config set-context test-doc --cluster=test-doc
kubectl config use-context test-doc

Test it out

List the nodes in your cluster by running:

kubectl get nodes

This should print:

NAME        LABELS                             STATUS
127.0.0.1   kubernetes.io/hostname=127.0.0.1   Ready

Run an application

kubectl run nginx --image=nginx --port=80

Now run docker ps you should see nginx running. You may need to wait a few minutes for the image to get pulled.

Expose it as a service

kubectl expose deployment nginx --port=80

Run the following command to obtain the IP of this service we just created. There are two IPs, the first one is internal (CLUSTER_IP), and the second one is the external load-balanced IP (if a LoadBalancer is configured)

kubectl get svc nginx

Alternatively, you can obtain only the first IP (CLUSTER_IP) by running:

kubectl get svc nginx --template={{.spec.clusterIP}}

Hit the webserver with the first IP (CLUSTER_IP):

curl <insert-cluster-ip-here>

Note that you will need run this curl command on your boot2docker VM if you are running on OS X.

Deploy a DNS

See here for instructions.

A note on turning down your cluster

Many of these containers run under the management of the kubelet binary, which attempts to keep containers running, even if they fail. So, in order to turn down the cluster, you need to first kill the kubelet container, and then any other containers.

You may use docker kill $(docker ps -aq), note this removes all containers running under Docker, so use with caution.

Troubleshooting

Node is in `NotReady` state

If you see your node as NotReady it's possible that your OS does not have memcg and swap enabled.

Your kernel should support memory and swap accounting. Ensure that the following configs are turned on in your linux kernel:
```
CONFIG_RESOURCE_COUNTERS=y
CONFIG_MEMCG=y
CONFIG_MEMCG_SWAP=y
CONFIG_MEMCG_SWAP_ENABLED=y
CONFIG_MEMCG_KMEM=y
```
Enable the memory and swap accounting in the kernel, at boot, as command line parameters as follows:
```
GRUB_CMDLINE_LINUX="cgroup_enable=memory swapaccount=1"
```
NOTE: The above is specifically for GRUB2. You can check the command line parameters passed to your kernel by looking at the output of /proc/cmdline:
```
$ cat /proc/cmdline
BOOT_IMAGE=/boot/vmlinuz-3.18.4-aufs root=/dev/sda5 ro cgroup_enable=memory swapaccount=1
```

5.7 KiB Raw Blame History