The first step for using Kubernetes is getting your software into a container. Docker is the easiest way to create these containers, and it is a fairly simple process. Let's take a moment to look at an existing container image to understand what choices you will need to make when creating your own containers:

docker pull docker.io/jocatalin/kubernetes-bootcamp:v1

First, you'll see it pulling down a list of files with arcane IDs. You'll see them updating in parallel, as it tries to grab these as they're available:

v1: Pulling from jocatalin/kubernetes-bootcamp
5c90d4a2d1a8: Downloading  3.145MB/51.35MB
ab30c63719b1: Downloading  3.931MB/18.55MB
29d0bc1e8c52: Download complete
d4fe0dc68927: Downloading  2.896MB/13.67MB
dfa9e924f957: Waiting

And when the downloads are complete, the output will update to say extracting, and finally pull complete:

v1...

Making a container is something easily done with the Docker software and the docker build command. This command uses a manifest that details how to create the container, called a Dockerfile.

Let's start with the simplest possible container. Create a file called a Dockerfile and add this to it:

FROM alpine
CMD ["/bin/sh", "-c", "echo 'hello world'"]

And then, invoke build:

docker build .

If you see a response like this:

"docker build" requires exactly 1 argument.
See 'docker build --help'.
Usage: docker build [OPTIONS] PATH | URL | -
Build an image from a Dockerfile

Then you are either missing the . in the command, or ran the command in a directory different from where you created the Dockerfile. The . is telling docker where to find Dockerfile (. meaning] in this current directory...

To walk through the details of how to use Kubernetes, I have created two sample applications that you can download, or replicate to follow along and try out these commands. The first of these is a very simple Python application using the Flask library. The sample application is directly from the Flask documentation (http://flask.pocoo.org/docs/0.12/).

You can download a copy of this code from GitHub at https://github.com/kubernetes-for-developers/kfd-flask/tree/first_container. Since we will evolve these files, the code referenced here is available at the first_container tag. If you want to use Git to get these files, you can run the following commands:

git clone https://github.com/kubernetes-for-developers/kfd-flask

Then, go into the repository and check out the tag: 

cd kfd-flask
git checkout tags/first_container

Let&apos...

This example follows the same pattern as the Python example, a simple Node.js application built with the Express library to walk through the details of how to use Kubernetes. If you are more familiar with JavaScript development, this example may be more meaningful. The sample application is directly from the Express documentation (https://expressjs.com/en/starter/generator.html).

You can get a download a copy of this code from GitHub at https://github.com/kubernetes-for-developers/kfd-nodejs/tree/first_container. Since we will evolve these files, the code referenced here is available at the first_container tag. If you want to use Git to retrieve these files, you can do so using the following commands:

git clone https://github.com/kubernetes-for-developers/kfd-nodejs
cd kfd-nodejs
git checkout tags/first_container

Like the...

Using the :latest tag on Docker images is incredibly convenient, but it can easily lead to confusion as to what exactly is running. If you do use :latest, then it is a very good idea to also tell Kubernetes to always attempt to pull a new image when loading the container. We will see how to set this in Chapter 4, Declarative Infrastructure, when we talk about declaratively defining our applications.

An alternative is to make explicit tags, building with a tag, and also using docker tag to tag the image as latest for the convenience factor, but maintaining specific tags within the declarations that you check in to source control. For this example, the tag chosen is 0.2.0, using semantic versioning to represent a value to use with the container, and matched to a git tag as well.

The steps that were used while making this example were:

git tag 0...

In this chapter, we reviewed what makes up a container, how to store and share containers on the internet, and some of the commands you can use to create your own containers. We then used that knowledge to walk through an example in Python and another in Node.js, creating simple web-based services in both, building those into container images, and running them within Kubernetes. In our next chapter, we will dive deeper into how to interact with your code once it's been packaged into a container and will explore tips for taking full advantage of containers and Kubernetes during your development.