Kubernetes stateless applications

Create a database service

It's very likely that your application code will need to communicate with other containerized code in the same Kubernetes cluster. Kubernetes makes networking your containers together very easy, using DNS.

In this step you will deploy a service for a database, and modify your app code so that it uses the database.

The application will return the number of requests or "hits" that it has received. The number of hits is maintained in a database.

Database container

Here's a deployment file that will run Postgres for you.

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: postgres
spec:
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
      - image: "postgres:10.1"
        name: postgres
        envFrom:
        - configMapRef:
            name: pg-config
        ports:
        - containerPort: 5432
          name: postgres
        volumeMounts:
        - name: postgres-storage
          mountPath: /var/lib/postgresql/data
      volumes:
      - name: postgres-storage
        hostPath:
          path: /var/lib/pg/data

You can use a pre-existing container image for Postgres
This file refers to a configMap - this is coming up next
This deployment uses a hostPath volume, which means the containers in this deployment can access a directory on the host node. This will work for our demonstration purposes today, because we only have one node. In a production deployment you would have your containers use other types of storage

The deployment refers to a ConfigMap, which is a way of passing environment variables into a container. Let's define that next.

apiVersion: v1
kind: ConfigMap
metadata:
  name: pg-config
data:
  PGDATA: /var/lib/postgresql/data/pgdata
  POSTGRES_USER: postgres

Create the ConfigMap and the Postgres deployment:

kubectl apply -f pg-cfg.yaml

kubectl apply -f pg-deployment.yaml

If you get an error, it may be that Kubernetes has not yet started in your environment. Wait for kubectl get nodes to show you that there is a node in Ready state - it could take a minute or two.

Initialize the database

As a one-off exercise you need to initialize the Postgres database. To do this you will "exec in" to the postgres container in the pod - if you like, you can think of this as like SSH-ing into the container.

Check that there is a postgres pod running:

kubectl get pods

Find the ID of the postgres pod.

export pod=$(kubectl get pods -l app=postgres --no-headers -o custom-columns=":metadata.name")

kubectl exec -it $pod sh

You are now in a shell in the Postgres container. For the purposes of this demonstration you're going to manually create the database called "hello" that your Go app is going to use:

createdb -U postgres hello

And still inside the Postgres container you can manually create a "hits" table inside this database.

psql -U postgres

Connect to the hello database:

\c hello

Create and initialize the hits table in this database:

CREATE TABLE hits (total int);

INSERT INTO hits (total) VALUES (0);

Quit out of psql and out of the container.

\q

exit

Database service

Postgres is running in a container in a pod, and that pod has an IP address which you can see if you get the details for it with kubectl describe:

kubectl describe pods -l app=postgres

This IP address is dynamically allocated each time a pod is created. When you write your web application, it is going to need to connect to the database pod, but it won't know the IP address. Instead, we will create a service, and the application can refer to the service by name.

apiVersion: v1
kind: Service
metadata:
  name: postgres-svc
spec:
  type: NodePort
  ports:
  - port: 5432
  selector:
    app: postgres

Create this service:

kubectl apply -f pg-svc.yaml

See everything that is up and running with kubectl get all

In fact, this is just showing you everything that is running in the default namespace. Namespaces are a way of group resources together - for example, some organizations use namespaces to separate the resources that apply to different applications, or that are owned by different teams. You'll see another namespace shortly.

Next steps

You now have a Kubernetes service running Postgres. In the next step you will write a Go application that will use it.

Write a Go application

Go app using the database

Here is a very simple go app that will increment a hit count every time it serves a response.

package main

import (
  "database/sql"
  "fmt"
  "net/http"


  _ "github.com/lib/pq"
)

var db *sql.DB

func main() {
  db = getDatabase()
  defer db.Close()  

    http.HandleFunc("/", handler)

    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        fmt.Printf("ListenAndServe exited with error %v\n", err)
    }
}

func getDatabase() *sql.DB {
  host := "postgres-svc"
  port := 5432
  user := "postgres"
  dbname := "hello"
  psqlInfo := fmt.Sprintf("host=%s port=%d user=%s "+
    "dbname=%s sslmode=disable",
    host, port, user, dbname)

  db, err := sql.Open("postgres", psqlInfo)
  if err != nil {
    fmt.Printf("Failed to open database: %v\n", err)
    panic(err)
  }
  fmt.Println("Opened database")

  return db  
}

func incrementCount() int {
    var hits int
    row := db.QueryRow("UPDATE hits SET total = total + 1 RETURNING total;")
    err := row.Scan(&hits)
    if err != nil {
        fmt.Printf("Database increment error: %v\n", err)
        return -1
    }
    return hits
}

func handler(w http.ResponseWriter, r *http.Request) {
    hits := incrementCount()
    response := fmt.Sprintf("hits: %d\n", hits)
    w.Write([]byte(response))
}

Kubernetes service resolution

Notice that the hostname for the database is hard-coded to postgres-svc in the first line of the getDatabase() function. Kubernetes uses DNS to resolve host names to IP addresses within the cluster, in much the same way that domain names are resolved to IP addresses across the internet.

We need to go get a package from a Git repository and this requires us to install git into the first stage of the multistage build. This means our Dockerfile looks like this:

FROM golang:1.12-alpine3.10

# Move to the directory where the source code will live
WORKDIR /go/src/hello

# Install git which will be used by go get
RUN apk add git

# Copy the source code into the current directory
COPY . .

# Get any dependencies, and compile the code
RUN CGO_ENABLED=0 go get -v ./...

# Second stage: start from an empty base image
FROM scratch

# Copy the binary from the first stage
COPY --from=0 /go/bin/hello /

# Tell Docker what executable to run by default when starting this container
ENTRYPOINT ["/hello"]

Build the container image.

docker build -t hello .

Next steps and further reading

In the next step you will deploy your app under Kubernetes.

Before you move on, if you like you can take a look at the Kubernetes DNS service components. The Kubernetes DNS service runs as a pod within Kubernetes, but within a separate namespace called kube-system. You can see the pods in this namespace with the following command:

kubectl get pods -n kube-system

Deploy the web application

You can now create the deployment and service for your "hello" web application.

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: hello
spec:
  replicas: 2
  template:
    metadata:
      labels:
        app: hello
    spec:
      containers:
      - name: hello
        image: hello:latest
        imagePullPolicy: Never

kubectl apply -f deployment.yaml

Check that the pods start up alright, noticing that you now have pods for both the hello app and the postgres database service that it is connecting to.

kubectl get pods

Now create a service for the web application:

apiVersion: v1
kind: Service
metadata:
  name: hello-svc
spec:
  type: NodePort
  ports:
  - targetPort: 8080
    port: 30000
  selector:
    app: hello

Apply this service YAML:

kubectl apply -f service.yaml

Next steps

In the next step you'll see if it is working as expected!

Check that everything is working

You should now have services for the postgres database and for the web app (plus the kubernetes service itself):

kubectl get services

This will show you the Cluster IP address that has been allocated to each service. You can use this address to make requests to the service. You are going to make curl requests to the hello web application so let's find its IP address.

read -p "Enter the cluster IP address for hello-svc: " clusterip

Try making a request to the service:

curl $clusterip:30000

If you do this a few times you should see that responses could come from either of the pods behind the service.

Notes and extra exercises

The web app is stateless in that it doesn't hold any data itself. All the state that is important to the application - in this case, the number of hits - is stored in a separate database. This means you can have several instances of the web app pod running simultaneously. The database takes care of serializing the increments to the hits table.

As an extra exercise you could modify the Go app so that its response includes the host name so that you can verify which pod is handling each request.
You could also try scaling the deployments of each service up and down with kubectl scale deployment _deployment_name_ --replicas=_replica_count

The ability to scale services independently to cope with demand is one of the features of Kubernetes that makes it "cloud native".

cd <directory>	Change directory
ls	List directory
echo 'contents' > <file>	Write contents to a file
cat <file>	Output contents of file

i	In Command Mode	Change into Insert Mode, you can now insert and edit text in the file
esc	In Insert Mode	Change into Command Mode, you can now execute commands
:wq	In Command Mode	Save and Exit

Welcome!

Congratulations!

You've completed the scenario!

Scenario Rating

Steps