Docker & Kubernetes 2 : minikube Django with Postgres - persistent volume

bogotobogo.com site search:

Note

Continued from the previous Kubernetes minikube (Docker & Kubernetes 1 : minikube A), we'll use Django with other apps side by side.

Kubernetes version info:

$ kubectl version
Client Version: version.Info{Major:"1", Minor:"11", GitVersion:"v1.11.3", GitCommit:"a4529464e4629c21224b3d52edfe0ea91b072862", GitTreeState:"clean", BuildDate:"2018-09-10T11:44:36Z", GoVersion:"go1.11", Compiler:"gc", Platform:"darwin/amd64"}
Server Version: version.Info{Major:"1", Minor:"10", GitVersion:"v1.10.0", GitCommit:"fc32d2f3698e36b93322a3465f63a14e9f0eaead", GitTreeState:"clean", BuildDate:"2018-03-26T16:44:10Z", GoVersion:"go1.9.3", Compiler:"gc", Platform:"linux/amd64"}

Starter Django App

Here is a screen shot output from our initial Django app (kubernetes_django/minikube-2/):

$ docker build -t dockerbogo/django-minikube:1.0.0 .
$ docker push dockerbogo/django-minikube:1.0.0

$ kubectl create -f deployment.yaml
$ kubectl create -f service.yaml

$ minikube service django-service --url

Django with Postgres

To test if it works with local virtual environment, we need to install (in this case, for Mac):

$ brew install postgres

$ pg_ctl -D /usr/local/var/postgres start
...
...listening on IPv4 address "127.0.0.1", port 5432
...listening on Unix socket "/tmp/.s.PGSQL.5432"

 done
server started

$ postgres -V
postgres (PostgreSQL) 10.5

Since we installed Postgres from homebrew then we need to run:

$ /usr/local/opt/postgres/bin/createuser -s postgres

$ psql postgres
psql (10.5)
Type "help" for help.

postgres=# \l
                                      List of databases
   Name    |    Owner    | Encoding |   Collate   |    Ctype    |      Access privileges      
-----------+-------------+----------+-------------+-------------+-----------------------------
 postgres  | kihyuckhong | UTF8     | en_US.UTF-8 | en_US.UTF-8 | 
 template0 | kihyuckhong | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/kihyuckhong             +
           |             |          |             |             | kihyuckhong=CTc/kihyuckhong
 template1 | kihyuckhong | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/kihyuckhong             +
           |             |          |             |             | kihyuckhong=CTc/kihyuckhong
(3 rows)

postgres=# \du
                                    List of roles
  Role name  |                         Attributes                         | Member of 
-------------+------------------------------------------------------------+-----------
 kihyuckhong | Superuser, Create role, Create DB, Replication, Bypass RLS | {}
 postgres    | Superuser, Create role, Create DB                          | {}

postgres=#

Let's set the password for the default postgres account-by default, it has no password:

postgres=# \password postgres
Enter new password: 
Enter it again: 
postgres=#

Creating DB and change owner:

postgres=# create database kube_django;
CREATE DATABASE
postgres=# \l
                                       List of databases
    Name     |    Owner    | Encoding |   Collate   |    Ctype    |      Access privileges      
-------------+-------------+----------+-------------+-------------+-----------------------------
 kube_django | kihyuckhong | UTF8     | en_US.UTF-8 | en_US.UTF-8 | 
 postgres    | kihyuckhong | UTF8     | en_US.UTF-8 | en_US.UTF-8 | 
 template0   | kihyuckhong | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/kihyuckhong             +
             |             |          |             |             | kihyuckhong=CTc/kihyuckhong
 template1   | kihyuckhong | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/kihyuckhong             +
             |             |          |             |             | kihyuckhong=CTc/kihyuckhong
(4 rows)

postgres=# ALTER DATABASE kube_django OWNER TO postgres;
ALTER DATABASE
postgres=# \l
                                       List of databases
    Name     |    Owner    | Encoding |   Collate   |    Ctype    |      Access privileges      
-------------+-------------+----------+-------------+-------------+-----------------------------
 kube_django | postgres    | UTF8     | en_US.UTF-8 | en_US.UTF-8 | 
 postgres    | kihyuckhong | UTF8     | en_US.UTF-8 | en_US.UTF-8 | 
 template0   | kihyuckhong | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/kihyuckhong             +
             |             |          |             |             | kihyuckhong=CTc/kihyuckhong
 template1   | kihyuckhong | UTF8     | en_US.UTF-8 | en_US.UTF-8 | =c/kihyuckhong             +
             |             |          |             |             | kihyuckhong=CTc/kihyuckhong
(4 rows)

Virtualenv:

$ virtualenv venv
$ source venv/bin/activate

(venv) $ pip install -r requirements.txt

(venv) $ python manage.py makemigrations
(venv) $ python manage.py migrate

After creating the database structure, we can create an administrative account by typing:

(venv) $ python manage.py createsuperuser

We will be asked to select a username, provide an email address, and choose and confirm a password (in this case, I set it to "superuser') for the account.

(venv) $ python manage.py createsuperuser
Username (leave blank to use 'kihyuckhong'): django
Email address: kihyuck.hong@gmail.com
...
Superuser created successfully.

Once we have an admin account set up, we can test if our database is performing correctly by starting up the Django development server:

(venv) $ python manage.py runserver 0.0.0.0:8000

In the web browser, visit the server's domain name or IP address followed by :8000 to reach default Django root page:

http://server_domain_or_IP:8000

We should see the following pages:

Exit from virtualenv:

(venv) $ deactivate

Local minikube setup

Start Minikube and to use minikube docker daemon instead of the host docker daemon:

$ minikube start
$ eval $(minikube docker-env)

To view the resources on the local cluster, the minikube dashboard can be up by using the command:

$ minikube dashboard

We'll be using the files in kubernetes_django/minikube-2B/.

Quick Run

Let's skip over any details, and just run. We'll go over the details later in this article:

$ docker build -t dockerbogo/django-minikube-2b:1.0.0 .

$ docker push dockerbogo/django-minikube-2b:1.0.0

$ kubectl apply -f kube_deploy_postgres/
secret/postgres-credentials created
service/postgres-service created
persistentvolume/postgres-pv created
persistentvolumeclaim/postgres-pvc created

$ kubectl apply -f kube_deploy_django/
Warning: kubectl apply should be used on resource created by either kubectl create --save-config or kubectl apply
deployment.apps/django configured
job.batch/django-migrations created
Warning: kubectl apply should be used on resource created by either kubectl create --save-config or kubectl apply
service/django-service configured

$ kubectl get all
NAME                            READY     STATUS      RESTARTS   AGE
pod/django-5fd955498b-4rsbz     1/1       Running     0          10s
pod/django-migrations-xssz9     0/1       Completed   0          10s
pod/postgres-69c85f5989-s47qz   1/1       Running     0          34s

NAME                       TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
service/django-service     LoadBalancer   10.98.105.236   <pending>     8000:32035/TCP   10s
service/kubernetes         ClusterIP      10.96.0.1       <none>        443/TCP          3d
service/postgres-service   ClusterIP      10.97.164.233   <none>        5432/TCP         34s

NAME                       DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/django     1         1         1            1           10s
deployment.apps/postgres   1         1         1            1           34s

NAME                                  DESIRED   CURRENT   READY     AGE
replicaset.apps/django-5fd955498b     1         1         1         10s
replicaset.apps/postgres-69c85f5989   1         1         1         34s

NAME                          DESIRED   SUCCESSFUL   AGE
job.batch/django-migrations   1         1            10s


$ kubectl get pv
NAME          CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS    CLAIM                  STORAGECLASS   REASON    AGE
postgres-pv   2Gi        RWX            Retain           Bound     default/postgres-pvc   standard                 3m

$ kubectl get pvc
NAME           STATUS    VOLUME        CAPACITY   ACCESS MODES   STORAGECLASS   AGE
postgres-pvc   Bound     postgres-pv   2Gi        RWX            standard       3m

$ minikube service django-service
There is a newer version of minikube available (v0.30.0).  Download it here:
https://github.com/kubernetes/minikube/releases/tag/v0.30.0

To disable this notification, run the following:
minikube config set WantUpdateNotification false
Opening kubernetes service default/django-service in default browser...

Persistent Volumes

A PersistentVolume (PV) is a storage in the cluster that has been provisioned by an administrator. It is a resource in the cluster just like a node is a cluster resource. PVs are volume plugins like Volumes, but have a lifecycle independent of any individual pod that uses the PV. This API object captures the details of the implementation of the storage, be that NFS, iSCSI, or a cloud-provider-specific storage system.

A PersistentVolumeClaim (PVC) is a request for storage by a user. It is similar to a pod. Pods consume node resources and PVCs consume PV resources. Pods can request specific levels of resources (CPU and Memory). Claims can request specific size and access modes (e.g., can be mounted once read/write or many times read-only).

Ref: Persistent Volumes

References

Persistent Volumes

Kubernetes, Local to Production with Django: 3 - Postgres with Migrations on Minikube