In our previous step we installed Kubernetes (k8s) on our Stack of NUCs.

Now we are going to install a web app and expose it to our internal network.

Purpose:

• Demonstrate a running a web application on Kubernetes

References

• https://gitlab.com/doritoes/speedtester
• https://hub.docker.com/repository/docker/doritoes/speedtester/general
• https://docs.ansible.com/ansible/latest/collections/kubernetes/core/k8s_module.html

From NUC 1, log in to the Ansible control node, NUC 2, then log in to the Kubernetes control node.

1. Create the YAML file to create the distribution

   • speedtester-deployment.yml

     apiVersion: apps/v1
     kind: Deployment
     metadata:
       name: speedtester
       labels:
         run: speedtester
     spec:
       selector:
         matchLabels:
           run: speedtester
       replicas: 2
       template:
         metadata:
           labels:
             run: speedtester
         spec:
           containers:
           - name: speedtester
             image: docker.io/doritoes/speedtester:latest
             livenessProbe:
               httpGet:
                 path: /favicon.ico
                 port: 80
               initialDelaySeconds: 3
               periodSeconds: 3

2. Apply the definition deployment
   • kubectl apply -f speedtester-deployment.yml
3. View distribution information
   • kubectl get pods,deployments
   • kubectl describe deployments speedtester
   • kubectl get deployment speedtester -o yaml
4. Increase number of replicas
   • Edit the file speedtester-deployment.yaml to set the number of replicas to the number of Kubernetes worker nodes you have
   • kubectl apply-f speedtester-deployment.yaml
   • kubectl get pods -w
   • kubectl get deployments
   • kubectl describe deployments speedtester
   • kubectl get deployment speedtester -o yaml

1. Create a service
   1. Using expose

      • kubectl expose deployment speedtester --port=8080 --name=speedtester-service --target-port=80

      • Removing it

      • kubctl get svc
        kubecgtl delete svc speedtester-service

   2. Using a manifest

      • speedtester-service.yml

        apiVersion: v1
        kind: Service
        metadata:
          name: speedtester-service
        spec:
          selector:
            run: speedtester
          type: NodePort
          ports:
            - protocol: TCP
              port: 8080
              targetPort: 80
              nodePort: 30080

      • kubectl apply -f speedtester-service.yml
2. kubectl get all
3. kubectl describe svc speedtester-service

Point your web browser on NUC 1 to the IP address of any node and the port we selected, port 300080

http://IPADDRESSWORKER:30080

Congratulations, you have a working Web application on your Kubernetes cluster. Now continue to Install HAProxy.

Ansible can be used to do used for tasks such as

• restarting pods
• creating namespaces (example from documentation)
  • ansible web -m k8s -a “name=namespace2 state=present kind=Namespace api_version=v1”

Chaos engineering exercises the resiliency of a service by means of randomly or continually interrupting service.

Proper chaos testing: https://opensource.com/article/21/6/chaos-kubernetes-kube-monkey

Some small scale chase testing is outlined below.

You can watch what's happening a couple of ways:

• watch kubectl get pods
• kubectl get pods -w

Killing pods:

• watch pods terminating and creating

Rebooting nodes:

• worker nodes show status unknown on pods, then return to running
• once in a while the random selection hits the master node
  • watch to see what happens then

kubectl delete pod $(kubectl get pods -l run=speedtester -o jsonpath='{.items[0].metadata.name}')

while true; do
kubectl delete pod $(kubectl get pods -l run=speedtester -o jsonpath='{.items[0].metadata.name}')
done

This is slow because the loop structure is sequential.

ansible-playbook deletepod.yml

deletepod.yml

---
- name: Delete current pods matching speedtester
  hosts: localhost
  vars:
    pod_filter:
      - speedtester # beginning of the pod name
  gather_facts: false
  tasks:
    - name: Get a list of all pods from the namespace
      command: kubectl get pods --no-headers -o custom-columns=":metadata.name"
      register: pod_list
    - name: Print pod names
      debug:
        msg: "{{ item }}"
      loop: "{{ pod_list.stdout_lines }}"
      when: item is match(pod_filter|join('|'))
    - name: Delete matching pods
      command: kubectl delete pod "{{ item }}"
      loop: "{{ pod_list.stdout_lines }}"
      when: item is match(pod_filter|join('|'))

Using async we can limit the waiting to see if the command returns.

ansible-playbook deletepod-async.yml

deletepod-async.yml

---
- name: Delete current pods matching speedtester
  hosts: localhost
  vars:
    pod_filter:
      - speedtester # beginning of the pod name
  gather_facts: false
  tasks:
    - name: Get a list of all pods from the namespace
      command: kubectl get pods --no-headers -o custom-columns=":metadata.name"
      register: pod_list
    - name: Print pod names
      debug:
        msg: "{{ item }}"
      loop: "{{ pod_list.stdout_lines }}"
      when: item is match(pod_filter|join('|'))
    - name: Delete matching pods
      command: kubectl delete pod "{{ item }}"
      async: 5 # timeout in seconds
      poll: 1 # poll every second
      loop: "{{ pod_list.stdout_lines }}"
      when: item is match(pod_filter|join('|'))

ansible-playbook killpod-webservice.yml

killpod-webservice.yml

---
- name: Crash current pods matching speedtester
  hosts: localhost
  vars:
    pod_filter:
      - speedtester # beginning of the pod name
  gather_facts: false
  tasks:
    - name: Get a list of all pods from the namespace
      command: kubectl get pods --no-headers -o custom-columns=":metadata.name"
      register: pod_list
    - name: Print pod names
      debug:
        msg: "{{ item }}"
      loop: "{{ pod_list.stdout_lines }}"
      when: item is match(pod_filter|join('|'))
    - name: Stop nginx on the pod
      command: kubectl exec "{{ item }}" -- pkill supervisord
      async: 5 # timeout in seconds
      poll: 1 # poll every second
      loop: "{{ pod_list.stdout_lines }}"
      when: item is match(pod_filter|join('|'))

randomreboot.yml

---
- hosts: localhost
  connection: local
  gather_facts: no
  tasks:
    - add_host:
        name: "{{ item }}"
        groups: limited_selection
      loop: "{{ (groups['all'] | shuffle)[0:1] }}"

- hosts: limited_selection
  gather_facts: no
  tasks:
    - reboot: