Docker & Kubernetes 1 : minikube A

In this page, we'll use minikube to deploy apache's web, Flask app, and Django app.

Since we're already running a Docker daemon inside minikube, we should take advantage of this instead of relying on another VM so that we keep things simple.

To configure environment to use minikube’s Docker daemon, we just need to use docker-env:

$ eval $(minikube docker-env)

Let's setup a local registry, so Kubernetes can pull the image(s) from there:

$ docker run -d -p 5000:5000 --restart=always --name registry registry:2

A push or a pull accesses the Central Registry at index.docker.io. So, with the setup in the previous section, nothing has changed with the default behavior. But to push to or pull from our own registry, we just need to add the registry's location to the repository name. It will look like my.registry.address:port/repositoryname.

$ docker build -t <IMAGE_NAME>:<TAG> .
$ docker build -t my-app:1.0.0 .

We should now have an image named 'my-app' locally, check by using docker images. We can then publish it to our local docker registry. To push an image to a private registry and not the central Docker registry we must tag it with the registry hostname and port (if needed):

$ docker tag my-app localhost:5000/my-app:1.0.0

Running docker images should now output the following:

$ docker images|grep my-app
REPOSITORY             TAG      IMAGE ID       CREATED       SIZE
my-app                 1.0.0    2865bbbcfb95   3 hours ago   234MB
localhost:5000/my-app  1.0.0    2865bbbcfb95   3 hours ago   234MB

$ kubectl apply -f deployment.yml

$ kubectl get deployment
NAME     DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
my-app   1         1         1            1           31s

To delete a deployment, the command is:

$ kubectl delete deployment/<DEPLOYMENT_NAME>

Each pod created via deployment has a unique IP address within the cluster. Minikube service allows us to access the pod IP address from outside of the cluster.

To create a service, the following shell command is to be executed:

$ kubectl apply -f service.yml

Though the IP address of the pod is transient and may change, the Service always routes traffic to the right pods.

To delete the service:

$ kubectl delete svc/<service-name>

We should now see our pod and our service:

$ kubectl get all

The minikube service <SERVICE_NAME> --url command will give us a url where we can access the service. In order to open the exposed service, we can use minikube service <SERVICE_NAME> command, and the service can be viewed on the browser via <minikube_ip>:<nodePort> url:

$ minikube service my-app --url
http://192.168.99.100:31757

We may gather the info about the ip and port from:

$ minikube status
minikube: Running
cluster: Running
kubectl: Correctly Configured: pointing to minikube-vm at 192.168.99.100

$ kubectl get svc
NAME             TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)          AGE
django-service   NodePort    10.101.139.221   <none>        8000:31567/TCP   3m
kubernetes       ClusterIP   10.96.0.1        <none>        443/TCP          4h

Dockerfile:

FROM httpd:2.4-alpine

COPY ./index.html /usr/local/apache2/htdocs/

index.html:

Hello world!

deployment.yml:

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  labels:
    run: my-app
  name: my-app
spec:
  replicas: 1
  selector:
    matchLabels:
      run: my-app-exposed
  template:
    metadata:
      labels:
        run: my-app-exposed
    spec:
      containers:
      - image: localhost:5000/my-app:1.0.0
        name: my-app
        ports:
        - containerPort: 80
          protocol: TCP

service.yml:

apiVersion: v1
kind: Service
metadata:
  labels:
    run: my-app
  name: my-app
spec:
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    run: my-app-exposed
  type: NodePort

We can use Dockerhub repository instead of local repository:

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  labels:
    run: my-app
  name: my-app
spec:
  replicas: 1
  selector:
    matchLabels:
      run: my-app-exposed
  template:
    metadata:
      labels:
        run: my-app-exposed
    spec:
      containers:
      - image: dockerbogo/my-app:1.0.0
        name: my-app
        ports:
        - containerPort: 80
          protocol: TCP

To push the image to the DockerHub repo, we may want to tag it first, and then logging in to dockerhub (username: dockerbogo):

$ docker build -t my-app:1.0.0 .
$ docker tag my-app:1.0.0 dockerbogo/my-app:1.0.0

$ docker login -u dockerbogo
$ docker push dockerbogo/my-app:1.0.0

$ eval $(minikube docker-env)

$ docker build . -t flask-kubernetes-example:latest

$ kubectl run flask-kubernetes-example --image=flask-kubernetes-example:latest --port=5000 --image-pull-policy=Never
deployment.apps/flask-kubernetes-example created

$ kubectl expose deployment flask-kubernetes-example --type=NodePort
service/flask-kubernetes-example exposed

$ minikube service flask-kubernetes-example --url
http://192.168.99.100:32750

$ eval $(minikube docker-env)

$ docker build -t dockerbogo/flask-hello-kubernetes:2.0.0 .
$ docker push dockerbogo/flask-hello-kubernetes:2.0.0


$ kubectl apply -f deployment.yml
deployment.extensions/flask-hello-kubernetes-deployment created

$ kubectl get deployment
NAME                                DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
flask-hello-kubernetes-deployment   1         1         1            1           9s

$ kubectl apply -f service.yml
service/flask-hello-kubernetes-service created

$ kubectl get service
NAME                             TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)          AGE
flask-hello-kubernetes-service   LoadBalancer   10.103.44.203    <pending>     80:30148/TCP     1m

$ minikube service flask-hello-kubernetes-service --url
http://192.168.99.100:30148

To delete the deployment and the service:

$ kubectl delete -f deployment.yml
deployment.extensions "flask-hello-kubernetes-deployment" deleted

$ kubectl delete -f service.yml
service "flask-hello-kubernetes-service" deleted

The source files can be found here : Einsteinish/flask-hello-minikube

This app is a trimmed down version of https://cloud.google.com/python/django/kubernetes-engine dropped sql proxy and volumes.

$ docker build -t dockerbogo/django-polls:1.0.0 .

$ docker push dockerbogo/django-polls:1.0.0
The push refers to repository [docker.io/dockerbogo/django-polls]

$ kubectl apply -f polls.yml
deployment.extensions/polls created
service/polls created

$ kubectl get deployment
NAME                DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
polls               3         3         3            3           10s

$ kubectl get service
NAME             TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)          AGE
polls            LoadBalancer   10.101.178.134   <pending>     80:32625/TCP     22s

$ minikube service polls --url
http://192.168.99.100:32625

polls.yaml:

# [START kubernetes_deployment]
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: polls
  labels:
    app: polls
spec:
  replicas: 3
  template:
    metadata:
      labels:
        app: polls
    spec:
      containers:
      - name: polls-app
        # Replace  with your project ID or use `make template`
        image: dockerbogo/django-polls:1.0.0
        # This setting makes nodes pull the docker image every time before
        # starting the pod. This is useful when debugging, but should be turned
        # off in production.
        imagePullPolicy: Always
        ports:
        - containerPort: 8080
# [END kubernetes_deployment]

---

# [START service]
apiVersion: v1
kind: Service
metadata:
  name: polls
  labels:
    app: polls
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 8080
  selector:
    app: polls
# [END service]

$ kubectl delete -f polls.yaml
deployment.extensions "polls" deleted
service "polls" deleted

To run the Django app on our local computer, set up a Python development environment, including Python, pip, and virtualenv.

1. Create an isolated Python environment, and install dependencies:

$ virtualenv venv
$ source venv/bin/activate
$ pip install -r requirements.txt




2. Run the Django migrations to set up your models:

$ python manage.py makemigrations
$ python manage.py makemigrations polls
$ python manage.py migrate




3. Start a local web server:

$ python manage.py runserver




4. In our browser, go to http://localhost:8000.

Docker & K8s

1. Docker install on Amazon Linux AMI
2. Docker install on EC2 Ubuntu 14.04
3. Docker container vs Virtual Machine
4. Docker install on Ubuntu 14.04
5. Docker Hello World Application
6. Nginx image - share/copy files, Dockerfile
7. Working with Docker images : brief introduction
8. Docker image and container via docker commands (search, pull, run, ps, restart, attach, and rm)
9. More on docker run command (docker run -it, docker run --rm, etc.)
10. Docker Networks - Bridge Driver Network
11. Docker Persistent Storage
12. File sharing between host and container (docker run -d -p -v)
13. Linking containers and volume for datastore
14. Dockerfile - Build Docker images automatically I - FROM, MAINTAINER, and build context
15. Dockerfile - Build Docker images automatically II - revisiting FROM, MAINTAINER, build context, and caching
16. Dockerfile - Build Docker images automatically III - RUN
17. Dockerfile - Build Docker images automatically IV - CMD
18. Dockerfile - Build Docker images automatically V - WORKDIR, ENV, ADD, and ENTRYPOINT
19. Docker - Apache Tomcat
20. Docker - NodeJS
21. Docker - NodeJS with hostname
22. Docker Compose - NodeJS with MongoDB
23. Docker - Prometheus and Grafana with Docker-compose
24. Docker - StatsD/Graphite/Grafana
25. Docker - Deploying a Java EE JBoss/WildFly Application on AWS Elastic Beanstalk Using Docker Containers
26. Docker : NodeJS with GCP Kubernetes Engine
27. Docker : Jenkins Multibranch Pipeline with Jenkinsfile and Github
28. Docker : Jenkins Master and Slave
29. Docker - ELK : ElasticSearch, Logstash, and Kibana
30. Docker - ELK 7.6 : Elasticsearch on Centos 7
31. Docker - ELK 7.6 : Filebeat on Centos 7
32. Docker - ELK 7.6 : Logstash on Centos 7
33. Docker - ELK 7.6 : Kibana on Centos 7
34. Docker - ELK 7.6 : Elastic Stack with Docker Compose
35. Docker - Deploy Elastic Cloud on Kubernetes (ECK) via Elasticsearch operator on minikube
36. Docker - Deploy Elastic Stack via Helm on minikube
37. Docker Compose - A gentle introduction with WordPress
38. Docker Compose - MySQL
39. MEAN Stack app on Docker containers : micro services
40. MEAN Stack app on Docker containers : micro services via docker-compose
41. Docker Compose - Hashicorp's Vault and Consul Part A (install vault, unsealing, static secrets, and policies)
42. Docker Compose - Hashicorp's Vault and Consul Part B (EaaS, dynamic secrets, leases, and revocation)
43. Docker Compose - Hashicorp's Vault and Consul Part C (Consul)
44. Docker Compose with two containers - Flask REST API service container and an Apache server container
45. Docker compose : Nginx reverse proxy with multiple containers
46. Docker & Kubernetes : Envoy - Getting started
47. Docker & Kubernetes : Envoy - Front Proxy
48. Docker & Kubernetes : Ambassador - Envoy API Gateway on Kubernetes
49. Docker Packer
50. Docker Cheat Sheet
51. Docker Q & A #1
52. Kubernetes Q & A - Part I
53. Kubernetes Q & A - Part II
54. Docker - Run a React app in a docker
55. Docker - Run a React app in a docker II (snapshot app with nginx)
56. Docker - NodeJS and MySQL app with React in a docker
57. Docker - Step by Step NodeJS and MySQL app with React - I
58. Installing LAMP via puppet on Docker
59. Docker install via Puppet
60. Nginx Docker install via Ansible
61. Apache Hadoop CDH 5.8 Install with QuickStarts Docker
62. Docker - Deploying Flask app to ECS
63. Docker Compose - Deploying WordPress to AWS
64. Docker - WordPress Deploy to ECS with Docker-Compose (ECS-CLI EC2 type)
65. Docker - WordPress Deploy to ECS with Docker-Compose (ECS-CLI Fargate type)
66. Docker - ECS Fargate
67. Docker - AWS ECS service discovery with Flask and Redis
68. Docker & Kubernetes : minikube
69. Docker & Kubernetes 2 : minikube Django with Postgres - persistent volume
70. Docker & Kubernetes 3 : minikube Django with Redis and Celery
71. Docker & Kubernetes 4 : Django with RDS via AWS Kops
72. Docker & Kubernetes : Kops on AWS
73. Docker & Kubernetes : Ingress controller on AWS with Kops
74. Docker & Kubernetes : HashiCorp's Vault and Consul on minikube
75. Docker & Kubernetes : HashiCorp's Vault and Consul - Auto-unseal using Transit Secrets Engine
76. Docker & Kubernetes : Persistent Volumes & Persistent Volumes Claims - hostPath and annotations
77. Docker & Kubernetes : Persistent Volumes - Dynamic volume provisioning
78. Docker & Kubernetes : DaemonSet
79. Docker & Kubernetes : Secrets
80. Docker & Kubernetes : kubectl command
81. Docker & Kubernetes : Assign a Kubernetes Pod to a particular node in a Kubernetes cluster
82. Docker & Kubernetes : Configure a Pod to Use a ConfigMap
83. AWS : EKS (Elastic Container Service for Kubernetes)
84. Docker & Kubernetes : Run a React app in a minikube
85. Docker & Kubernetes : Minikube install on AWS EC2
86. Docker & Kubernetes : Cassandra with a StatefulSet
87. Docker & Kubernetes : Terraform and AWS EKS
88. Docker & Kubernetes : Pods and Service definitions
89. Docker & Kubernetes : Service IP and the Service Type
90. Docker & Kubernetes : Kubernetes DNS with Pods and Services
91. Docker & Kubernetes : Headless service and discovering pods
92. Docker & Kubernetes : Scaling and Updating application
93. Docker & Kubernetes : Horizontal pod autoscaler on minikubes
94. Docker & Kubernetes : From a monolithic app to micro services on GCP Kubernetes
95. Docker & Kubernetes : Rolling updates
96. Docker & Kubernetes : Deployments to GKE (Rolling update, Canary and Blue-green deployments)
97. Docker & Kubernetes : Slack Chat Bot with NodeJS on GCP Kubernetes
98. Docker & Kubernetes : Continuous Delivery with Jenkins Multibranch Pipeline for Dev, Canary, and Production Environments on GCP Kubernetes
99. Docker & Kubernetes : NodePort vs LoadBalancer vs Ingress
100. Docker & Kubernetes : MongoDB / MongoExpress on Minikube
101. Docker & Kubernetes : Load Testing with Locust on GCP Kubernetes
102. Docker & Kubernetes : MongoDB with StatefulSets on GCP Kubernetes Engine
103. Docker & Kubernetes : Nginx Ingress Controller on Minikube
104. Docker & Kubernetes : Setting up Ingress with NGINX Controller on Minikube (Mac)
105. Docker & Kubernetes : Nginx Ingress Controller for Dashboard service on Minikube
106. Docker & Kubernetes : Nginx Ingress Controller on GCP Kubernetes
107. Docker & Kubernetes : Kubernetes Ingress with AWS ALB Ingress Controller in EKS
108. Docker & Kubernetes : Setting up a private cluster on GCP Kubernetes
109. Docker & Kubernetes : Kubernetes Namespaces (default, kube-public, kube-system) and switching namespaces (kubens)
110. Docker & Kubernetes : StatefulSets on minikube
111. Docker & Kubernetes : RBAC
112. Docker & Kubernetes Service Account, RBAC, and IAM
113. Docker & Kubernetes - Kubernetes Service Account, RBAC, IAM with EKS ALB, Part 1
114. Docker & Kubernetes : Helm Chart
115. Docker & Kubernetes : My first Helm deploy
116. Docker & Kubernetes : Readiness and Liveness Probes
117. Docker & Kubernetes : Helm chart repository with Github pages
118. Docker & Kubernetes : Deploying WordPress and MariaDB with Ingress to Minikube using Helm Chart
119. Docker & Kubernetes : Deploying WordPress and MariaDB to AWS using Helm 2 Chart
120. Docker & Kubernetes : Deploying WordPress and MariaDB to AWS using Helm 3 Chart
121. Docker & Kubernetes : Helm Chart for Node/Express and MySQL with Ingress
122. Docker & Kubernetes : Deploy Prometheus and Grafana using Helm and Prometheus Operator - Monitoring Kubernetes node resources out of the box
123. Docker & Kubernetes : Deploy Prometheus and Grafana using kube-prometheus-stack Helm Chart
124. Docker & Kubernetes : Istio (service mesh) sidecar proxy on GCP Kubernetes
125. Docker & Kubernetes : Istio on EKS
126. Docker & Kubernetes : Istio on Minikube with AWS EC2 for Bookinfo Application
127. Docker & Kubernetes : Deploying .NET Core app to Kubernetes Engine and configuring its traffic managed by Istio (Part I)
128. Docker & Kubernetes : Deploying .NET Core app to Kubernetes Engine and configuring its traffic managed by Istio (Part II - Prometheus, Grafana, pin a service, split traffic, and inject faults)
129. Docker & Kubernetes : Helm Package Manager with MySQL on GCP Kubernetes Engine
130. Docker & Kubernetes : Deploying Memcached on Kubernetes Engine
131. Docker & Kubernetes : EKS Control Plane (API server) Metrics with Prometheus
132. Docker & Kubernetes : Spinnaker on EKS with Halyard
133. Docker & Kubernetes : Continuous Delivery Pipelines with Spinnaker and Kubernetes Engine
134. Docker & Kubernetes : Multi-node Local Kubernetes cluster : Kubeadm-dind (docker-in-docker)
135. Docker & Kubernetes : Multi-node Local Kubernetes cluster : Kubeadm-kind (k8s-in-docker)
136. Docker & Kubernetes : nodeSelector, nodeAffinity, taints/tolerations, pod affinity and anti-affinity - Assigning Pods to Nodes
137. Docker & Kubernetes : Jenkins-X on EKS
138. Docker & Kubernetes : ArgoCD App of Apps with Heml on Kubernetes
139. Docker & Kubernetes : ArgoCD on Kubernetes cluster
140. Docker & Kubernetes : GitOps with ArgoCD for Continuous Delivery to Kubernetes clusters (minikube) - guestbook