diff --git a/configuration.md b/configuration.md index b347548..9da0bfc 100644 --- a/configuration.md +++ b/configuration.md @@ -12,671 +12,671 @@ ### TBD -
List all the configmaps in the cluster -

- -``` -kubectl get cm - or -kubectl get configmap -``` -

-
- - -
Create a configmap called myconfigmap with literal value appname=myapp -

- -``` -kubectl create cm myconfigmap --from-literal=appname=myapp -``` -

-
- - -
Verify the configmap we just created has this data -

- -``` -// you will see under data -kubectl get cm -o yaml +1.

List all the configmaps in the cluster +

+ + ``` + kubectl get cm or -kubectl describe cm -``` -

-
- - -
delete the configmap myconfigmap we just created -

- -``` -kubectl delete cm myconfigmap -``` -

-
- - -
Create a file called config.txt with two values key1=value1 and key2=value2 and verify the file -

- -``` -cat >> config.txt << EOF -key1=value1 -key2=value2 -EOF - -cat config.txt -``` -

-
- - -
Create a configmap named keyvalcfgmap and read data from the file config.txt and verify that configmap is created correctly -

- -``` -kubectl create cm keyvalcfgmap --from-file=config.txt - -kubectl get cm keyvalcfgmap -o yaml -``` -

-
- - - -
Create an nginx pod and load environment values from the above configmap keyvalcfgmap and exec into the pod and verify the environment variables and delete the pod -

- -``` -// first run this command to save the pod yml -kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml > nginx-pod.yml - -// edit the yml to below file and create -apiVersion: v1 -kind: Pod -metadata: - creationTimestamp: null - labels: - run: nginx - name: nginx -spec: - containers: - - image: nginx - name: nginx - resources: {} - envFrom: - - configMapRef: - name: keyvalcfgmap - dnsPolicy: ClusterFirst - restartPolicy: Never -status: {} - -kubectl create -f nginx-pod.yml - -// verify -kubectl exec -it nginx -- env -kubectl delete po nginx -``` -

-
- - -
Create an env file file.env with var1=val1 and create a configmap envcfgmap from this env file and verify the configmap -

- -``` -echo var1=val1 > file.env -cat file.env - -kubectl create cm envcfgmap --from-env-file=file.env -kubectl get cm envcfgmap -o yaml --export -``` -

-
- - -
Create an nginx pod and load environment values from the above configmap envcfgmap and exec into the pod and verify the environment variables and delete the pod -

- -``` -// first run this command to save the pod yml -kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml > nginx-pod.yml - -// edit the yml to below file and create -apiVersion: v1 -kind: Pod -metadata: - creationTimestamp: null - labels: - run: nginx - name: nginx -spec: - containers: - - image: nginx - name: nginx - resources: {} - env: - - name: ENVIRONMENT - valueFrom: - configMapKeyRef: - name: envcfgmap - key: environment - dnsPolicy: ClusterFirst - restartPolicy: Never -status: {} - -kubectl create -f nginx-pod.yml - -// verify -kubectl exec -it nginx -- env -kubectl delete po nginx -``` -

-
- - -
Create a configmap called cfgvolume with values var1=val1, var2=val2 and create an nginx pod with volume nginx-volume which reads data from this configmap cfgvolume and put it on the path /etc/cfg -

- -``` -// first create a configmap cfgvolume -kubectl create cm cfgvolume --from-literal=var1=val1 --from-literal=var2=val2 - -// verify the configmap -kubectl describe cm cfgvolume - -// create the config map -apiVersion: v1 -kind: Pod -metadata: - creationTimestamp: null - labels: - run: nginx - name: nginx -spec: - volumes: - - name: nginx-volume - configMap: - name: cfgvolume - containers: - - image: nginx - name: nginx - resources: {} - volumeMounts: - - name: nginx-volume - mountPath: /etc/cfg - dnsPolicy: ClusterFirst - restartPolicy: Never -status: {} - -kubectl create -f nginx-volume.yml - -// exec into the pod -kubectl exec -it nginx -- /bin/sh - -// check the path -cd /etc/cfg -ls -``` -

-
- - -
Create a pod called secbusybox with the image busybox which executes command sleep 3600 and makes sure any Containers in the Pod, all processes run with user ID 1000 and with group id 2000 and verify. -

- -``` -// create yml file with dry-run -kubectl run secbusybox --image=busybox --restart=Never --dry-run -o yaml -- /bin/sh -c "sleep 3600;" > busybox.yml - -// edit the pod like below and create -apiVersion: v1 -kind: Pod -metadata: - creationTimestamp: null - labels: - run: secbusybox - name: secbusybox -spec: - securityContext: # add security context - runAsUser: 1000 - runAsGroup: 2000 - containers: - - args: - - /bin/sh - - -c - - sleep 3600; - image: busybox - name: secbusybox - resources: {} - dnsPolicy: ClusterFirst - restartPolicy: Never -status: {} - -kubectl create -f busybox.yml - -// verify -kubectl exec -it secbusybox -- sh -id // it will show the id and group -``` -

-
- - -
Create the same pod as above this time set the securityContext for the container as well and verify that the securityContext of container overrides the Pod level securityContext. -

- -``` -// create yml file with dry-run -kubectl run secbusybox --image=busybox --restart=Never --dry-run -o yaml -- /bin/sh -c "sleep 3600;" > busybox.yml - -// edit the pod like below and create -apiVersion: v1 -kind: Pod -metadata: - creationTimestamp: null - labels: - run: secbusybox - name: secbusybox -spec: - securityContext: - runAsUser: 1000 - containers: - - args: - - /bin/sh - - -c - - sleep 3600; - image: busybox - securityContext: - runAsUser: 2000 - name: secbusybox - resources: {} - dnsPolicy: ClusterFirst - restartPolicy: Never -status: {} - -kubectl create -f busybox.yml - -// verify -kubectl exec -it secbusybox -- sh -id // you can see container securityContext overides the Pod level -``` -

-
- - -
Create pod with an nginx image and configure the pod with capabilities NET_ADMIN and SYS_TIME verify the capabilities -

- -``` -// create the yaml file -kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml > nginx.yml - -// edit as below and create pod -apiVersion: v1 -kind: Pod -metadata: - creationTimestamp: null - labels: - run: nginx - name: nginx -spec: - containers: - - image: nginx - securityContext: - capabilities: - add: ["SYS_TIME", "NET_ADMIN"] - name: nginx - resources: {} - dnsPolicy: ClusterFirst - restartPolicy: Never -status: {} - -kubectl create -f nginx.yml - -// exec and verify -kubectl exec -it nginx -- sh -cd /proc/1 -cat status - -// you should see these values -CapPrm: 00000000aa0435fb -CapEff: 00000000aa0435fb -``` -

-
- - -
Create a Pod nginx and specify a memory request and a memory limit of 100Mi and 200Mi respectively. -

- -``` -// create a yml file -kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml > nginx.yml - -// add the resources section and create -apiVersion: v1 -kind: Pod -metadata: - creationTimestamp: null - labels: - run: nginx - name: nginx -spec: - containers: - - image: nginx - name: nginx - resources: - requests: - memory: "100Mi" - limits: - memory: "200Mi" - dnsPolicy: ClusterFirst - restartPolicy: Never -status: {} - -kubectl create -f nginx.yml - -// verify -kubectl top pod -``` -

-
- - -
Create a Pod nginx and specify a CPU request and a CPU limit of 0.5 and 1 respectively. -

- -``` -// create a yml file -kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml > nginx.yml - -// add the resources section and create -apiVersion: v1 -kind: Pod -metadata: - creationTimestamp: null - labels: - run: nginx - name: nginx -spec: - containers: - - image: nginx - name: nginx - resources: - requests: - cpu: "0.5" - limits: - cpu: "1" - dnsPolicy: ClusterFirst - restartPolicy: Never -status: {} - -kubectl create -f nginx.yml - -// verify -kubectl top pod -``` -

-
- - -
Create a Pod nginx and specify both CPU, memory requests and limits together and verify. -

- -``` -// create a yml file -kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml > nginx.yml - -// add the resources section and create -apiVersion: v1 -kind: Pod -metadata: - creationTimestamp: null - labels: - run: nginx - name: nginx -spec: - containers: - - image: nginx - name: nginx - resources: - requests: - memory: "100Mi" - cpu: "0.5" - limits: - memory: "200Mi" - cpu: "1" - dnsPolicy: ClusterFirst - restartPolicy: Never -status: {} - -kubectl create -f nginx.yml - -// verify -kubectl top pod -``` -

-
- - -
Create a Pod nginx and specify a memory request and a memory limit of 100Gi and 200Gi respectively which is too big for the nodes and verify pod fails to start because of insufficient memory -

- -``` -// create a yml file -kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml > nginx.yml - -// add the resources section and create -apiVersion: v1 -kind: Pod -metadata: - creationTimestamp: null - labels: - run: nginx - name: nginx -spec: - containers: - - image: nginx - name: nginx - resources: - requests: - memory: "100Gi" - cpu: "0.5" - limits: - memory: "200Gi" - cpu: "1" - dnsPolicy: ClusterFirst - restartPolicy: Never -status: {} - -kubectl create -f nginx.yml - -// verify -kubectl describe po nginx // you can see pending state -``` -

-
- - -
Create a secret mysecret with values user=myuser and password=mypassword -

- -``` -kubectl create secret generic my-secret --from-literal=username=user --from-literal=password=mypassword -``` -

-
- - -
List the secrets in all namespaces -

- -``` -kubectl get secret --all-namespaces -``` -

-
- - -
Output the yaml of the secret created above -

- -``` -kubectl get secret my-secret -o yaml -``` -

-
- - -
Create an nginx pod which reads username as the environment variable -

- -``` -// create a yml file -kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml > nginx.yml - -// add env section below and create -apiVersion: v1 -kind: Pod -metadata: - creationTimestamp: null - labels: - run: nginx - name: nginx -spec: - containers: - - image: nginx - name: nginx - env: - - name: USER_NAME - valueFrom: - secretKeyRef: - name: my-secret - key: username - resources: {} - dnsPolicy: ClusterFirst - restartPolicy: Never -status: {} - -kubectl create -f nginx.yml - -//verify -kubectl exec -it nginx -- env -``` -

-
- - -
Create an nginx pod which loads the secret as environment variables -

- -``` -// create a yml file -kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml > nginx.yml - -// add env section below and create -apiVersion: v1 -kind: Pod -metadata: - creationTimestamp: null - labels: - run: nginx - name: nginx -spec: - containers: - - image: nginx - name: nginx - envFrom: - - secretRef: - name: my-secret - resources: {} - dnsPolicy: ClusterFirst - restartPolicy: Never -status: {} - -kubectl create -f nginx.yml - -//verify -kubectl exec -it nginx -- env -``` -

-
- - -
List all the service accounts in the default namespace -

- -``` -kubectl get sa -``` -

-
- - -
List all the service accounts in all namespaces -

- -``` -kubectl get sa --all-namespaces -``` -

-
- - -
Create a service account called admin -

- -``` -kubectl create sa admin -``` -

-
- - -
Output the YAML file for the service account we just created -

- -``` -kubectl get sa admin -o yaml -``` -

-
- - -
Create a busybox pod which executes this command sleep 3600 with the service account admin and verify -

- -``` -kubectl run busybox --image=busybox --restart=Never --dry-run -o yaml -- /bin/sh -c "sleep 3600" > busybox.yml - -kubectl create -f busybox.yml - -apiVersion: v1 -kind: Pod -metadata: - creationTimestamp: null - labels: - run: busybox - name: busybox -spec: - serviceAccountName: admin - containers: - - args: - - /bin/sh - - -c - - sleep 3600 - image: busybox - name: busybox - resources: {} - dnsPolicy: ClusterFirst - restartPolicy: Never -status: {} - -// verify -kubectl describe po busybox -``` -

-
+ kubectl get configmap + ``` +

+
+ + +2.
Create a configmap called myconfigmap with literal value appname=myapp +

+ + ``` + kubectl create cm myconfigmap --from-literal=appname=myapp + ``` +

+
+ + +3.
Verify the configmap we just created has this data +

+ + ``` + // you will see under data + kubectl get cm -o yaml + or + kubectl describe cm + ``` +

+
+ + +4.
delete the configmap myconfigmap we just created +

+ + ``` + kubectl delete cm myconfigmap + ``` +

+
+ + +5.
Create a file called config.txt with two values key1=value1 and key2=value2 and verify the file +

+ + ``` + cat >> config.txt << EOF + key1=value1 + key2=value2 + EOF + + cat config.txt + ``` +

+
+ + +6.
Create a configmap named keyvalcfgmap and read data from the file config.txt and verify that configmap is created correctly +

+ + ``` + kubectl create cm keyvalcfgmap --from-file=config.txt + + kubectl get cm keyvalcfgmap -o yaml + ``` +

+
+ + + +7.
Create an nginx pod and load environment values from the above configmap keyvalcfgmap and exec into the pod and verify the environment variables and delete the pod +

+ + ``` + // first run this command to save the pod yml + kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml > nginx-pod.yml + + // edit the yml to below file and create + apiVersion: v1 + kind: Pod + metadata: + creationTimestamp: null + labels: + run: nginx + name: nginx + spec: + containers: + - image: nginx + name: nginx + resources: {} + envFrom: + - configMapRef: + name: keyvalcfgmap + dnsPolicy: ClusterFirst + restartPolicy: Never + status: {} + + kubectl create -f nginx-pod.yml + + // verify + kubectl exec -it nginx -- env + kubectl delete po nginx + ``` +

+
+ + +8.
Create an env file file.env with var1=val1 and create a configmap envcfgmap from this env file and verify the configmap +

+ + ``` + echo var1=val1 > file.env + cat file.env + + kubectl create cm envcfgmap --from-env-file=file.env + kubectl get cm envcfgmap -o yaml --export + ``` +

+
+ + +9.
Create an nginx pod and load environment values from the above configmap envcfgmap and exec into the pod and verify the environment variables and delete the pod +

+ + ``` + // first run this command to save the pod yml + kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml > nginx-pod.yml + + // edit the yml to below file and create + apiVersion: v1 + kind: Pod + metadata: + creationTimestamp: null + labels: + run: nginx + name: nginx + spec: + containers: + - image: nginx + name: nginx + resources: {} + env: + - name: ENVIRONMENT + valueFrom: + configMapKeyRef: + name: envcfgmap + key: environment + dnsPolicy: ClusterFirst + restartPolicy: Never + status: {} + + kubectl create -f nginx-pod.yml + + // verify + kubectl exec -it nginx -- env + kubectl delete po nginx + ``` +

+
+ + +10.
Create a configmap called cfgvolume with values var1=val1, var2=val2 and create an nginx pod with volume nginx-volume which reads data from this configmap cfgvolume and put it on the path /etc/cfg +

+ + ``` + // first create a configmap cfgvolume + kubectl create cm cfgvolume --from-literal=var1=val1 --from-literal=var2=val2 + + // verify the configmap + kubectl describe cm cfgvolume + + // create the config map + apiVersion: v1 + kind: Pod + metadata: + creationTimestamp: null + labels: + run: nginx + name: nginx + spec: + volumes: + - name: nginx-volume + configMap: + name: cfgvolume + containers: + - image: nginx + name: nginx + resources: {} + volumeMounts: + - name: nginx-volume + mountPath: /etc/cfg + dnsPolicy: ClusterFirst + restartPolicy: Never + status: {} + + kubectl create -f nginx-volume.yml + + // exec into the pod + kubectl exec -it nginx -- /bin/sh + + // check the path + cd /etc/cfg + ls + ``` +

+
+ + +11.
Create a pod called secbusybox with the image busybox which executes command sleep 3600 and makes sure any Containers in the Pod, all processes run with user ID 1000 and with group id 2000 and verify. +

+ + ``` + // create yml file with dry-run + kubectl run secbusybox --image=busybox --restart=Never --dry-run -o yaml -- /bin/sh -c "sleep 3600;" > busybox.yml + + // edit the pod like below and create + apiVersion: v1 + kind: Pod + metadata: + creationTimestamp: null + labels: + run: secbusybox + name: secbusybox + spec: + securityContext: # add security context + runAsUser: 1000 + runAsGroup: 2000 + containers: + - args: + - /bin/sh + - -c + - sleep 3600; + image: busybox + name: secbusybox + resources: {} + dnsPolicy: ClusterFirst + restartPolicy: Never + status: {} + + kubectl create -f busybox.yml + + // verify + kubectl exec -it secbusybox -- sh + id // it will show the id and group + ``` +

+
+ + +12.
Create the same pod as above this time set the securityContext for the container as well and verify that the securityContext of container overrides the Pod level securityContext. +

+ + ``` + // create yml file with dry-run + kubectl run secbusybox --image=busybox --restart=Never --dry-run -o yaml -- /bin/sh -c "sleep 3600;" > busybox.yml + + // edit the pod like below and create + apiVersion: v1 + kind: Pod + metadata: + creationTimestamp: null + labels: + run: secbusybox + name: secbusybox + spec: + securityContext: + runAsUser: 1000 + containers: + - args: + - /bin/sh + - -c + - sleep 3600; + image: busybox + securityContext: + runAsUser: 2000 + name: secbusybox + resources: {} + dnsPolicy: ClusterFirst + restartPolicy: Never + status: {} + + kubectl create -f busybox.yml + + // verify + kubectl exec -it secbusybox -- sh + id // you can see container securityContext overides the Pod level + ``` +

+
+ + +13.
Create pod with an nginx image and configure the pod with capabilities NET_ADMIN and SYS_TIME verify the capabilities +

+ + ``` + // create the yaml file + kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml > nginx.yml + + // edit as below and create pod + apiVersion: v1 + kind: Pod + metadata: + creationTimestamp: null + labels: + run: nginx + name: nginx + spec: + containers: + - image: nginx + securityContext: + capabilities: + add: ["SYS_TIME", "NET_ADMIN"] + name: nginx + resources: {} + dnsPolicy: ClusterFirst + restartPolicy: Never + status: {} + + kubectl create -f nginx.yml + + // exec and verify + kubectl exec -it nginx -- sh + cd /proc/1 + cat status + + // you should see these values + CapPrm: 00000000aa0435fb + CapEff: 00000000aa0435fb + ``` +

+
+ + +14.
Create a Pod nginx and specify a memory request and a memory limit of 100Mi and 200Mi respectively. +

+ + ``` + // create a yml file + kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml > nginx.yml + + // add the resources section and create + apiVersion: v1 + kind: Pod + metadata: + creationTimestamp: null + labels: + run: nginx + name: nginx + spec: + containers: + - image: nginx + name: nginx + resources: + requests: + memory: "100Mi" + limits: + memory: "200Mi" + dnsPolicy: ClusterFirst + restartPolicy: Never + status: {} + + kubectl create -f nginx.yml + + // verify + kubectl top pod + ``` +

+
+ + +15.
Create a Pod nginx and specify a CPU request and a CPU limit of 0.5 and 1 respectively. +

+ + ``` + // create a yml file + kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml > nginx.yml + + // add the resources section and create + apiVersion: v1 + kind: Pod + metadata: + creationTimestamp: null + labels: + run: nginx + name: nginx + spec: + containers: + - image: nginx + name: nginx + resources: + requests: + cpu: "0.5" + limits: + cpu: "1" + dnsPolicy: ClusterFirst + restartPolicy: Never + status: {} + + kubectl create -f nginx.yml + + // verify + kubectl top pod + ``` +

+
+ + +16.
Create a Pod nginx and specify both CPU, memory requests and limits together and verify. +

+ + ``` + // create a yml file + kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml > nginx.yml + + // add the resources section and create + apiVersion: v1 + kind: Pod + metadata: + creationTimestamp: null + labels: + run: nginx + name: nginx + spec: + containers: + - image: nginx + name: nginx + resources: + requests: + memory: "100Mi" + cpu: "0.5" + limits: + memory: "200Mi" + cpu: "1" + dnsPolicy: ClusterFirst + restartPolicy: Never + status: {} + + kubectl create -f nginx.yml + + // verify + kubectl top pod + ``` +

+
+ + +17.
Create a Pod nginx and specify a memory request and a memory limit of 100Gi and 200Gi respectively which is too big for the nodes and verify pod fails to start because of insufficient memory +

+ + ``` + // create a yml file + kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml > nginx.yml + + // add the resources section and create + apiVersion: v1 + kind: Pod + metadata: + creationTimestamp: null + labels: + run: nginx + name: nginx + spec: + containers: + - image: nginx + name: nginx + resources: + requests: + memory: "100Gi" + cpu: "0.5" + limits: + memory: "200Gi" + cpu: "1" + dnsPolicy: ClusterFirst + restartPolicy: Never + status: {} + + kubectl create -f nginx.yml + + // verify + kubectl describe po nginx // you can see pending state + ``` +

+
+ + +18.
Create a secret mysecret with values user=myuser and password=mypassword +

+ + ``` + kubectl create secret generic my-secret --from-literal=username=user --from-literal=password=mypassword + ``` +

+
+ + +19.
List the secrets in all namespaces +

+ + ``` + kubectl get secret --all-namespaces + ``` +

+
+ + +20.
Output the yaml of the secret created above +

+ + ``` + kubectl get secret my-secret -o yaml + ``` +

+
+ + +21.
Create an nginx pod which reads username as the environment variable +

+ + ``` + // create a yml file + kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml > nginx.yml + + // add env section below and create + apiVersion: v1 + kind: Pod + metadata: + creationTimestamp: null + labels: + run: nginx + name: nginx + spec: + containers: + - image: nginx + name: nginx + env: + - name: USER_NAME + valueFrom: + secretKeyRef: + name: my-secret + key: username + resources: {} + dnsPolicy: ClusterFirst + restartPolicy: Never + status: {} + + kubectl create -f nginx.yml + + //verify + kubectl exec -it nginx -- env + ``` +

+
+ + +22.
Create an nginx pod which loads the secret as environment variables +

+ + ``` + // create a yml file + kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml > nginx.yml + + // add env section below and create + apiVersion: v1 + kind: Pod + metadata: + creationTimestamp: null + labels: + run: nginx + name: nginx + spec: + containers: + - image: nginx + name: nginx + envFrom: + - secretRef: + name: my-secret + resources: {} + dnsPolicy: ClusterFirst + restartPolicy: Never + status: {} + + kubectl create -f nginx.yml + + //verify + kubectl exec -it nginx -- env + ``` +

+
+ + +23.
List all the service accounts in the default namespace +

+ + ``` + kubectl get sa + ``` +

+
+ + +24.
List all the service accounts in all namespaces +

+ + ``` + kubectl get sa --all-namespaces + ``` +

+
+ + +25.
Create a service account called admin +

+ + ``` + kubectl create sa admin + ``` +

+
+ + +26.
Output the YAML file for the service account we just created +

+ + ``` + kubectl get sa admin -o yaml + ``` +

+
+ + +27.
Create a busybox pod which executes this command sleep 3600 with the service account admin and verify +

+ + ``` + kubectl run busybox --image=busybox --restart=Never --dry-run -o yaml -- /bin/sh -c "sleep 3600" > busybox.yml + + kubectl create -f busybox.yml + + apiVersion: v1 + kind: Pod + metadata: + creationTimestamp: null + labels: + run: busybox + name: busybox + spec: + serviceAccountName: admin + containers: + - args: + - /bin/sh + - -c + - sleep 3600 + image: busybox + name: busybox + resources: {} + dnsPolicy: ClusterFirst + restartPolicy: Never + status: {} + + // verify + kubectl describe po busybox + ``` +

+
diff --git a/core-concepts.md b/core-concepts.md index 50b95b9..1c237a2 100644 --- a/core-concepts.md +++ b/core-concepts.md @@ -7,333 +7,333 @@ ## Questions -
List all the namespaces in the cluster -

- -``` -kubectl get namespaces - -kubectl get ns -``` -

-
- -
List all the pods in all namespaces -

- -``` -kubectl get po --all-namespaces -``` -

-
- -
List all the pods in the particular namespace -

- -``` -kubectl get po -n -``` -

-
- -
List all the services in the particular namespace -

- -``` -kubectl get svc -n -``` -

-
- -
List all the pods showing name and namespace with a json path expression -

- -``` -kubectl get pods -o=jsonpath="{.items[*]['metadata.name', 'metadata.namespace']}" -``` -

-
- -
Create an nginx pod in a default namespace and verify the pod running -

- -``` -// creating a pod -kubectl run nginx --image=nginx --restart=Never - -// List the pod -kubectl get po -``` -

-
- - -
Create the same nginx pod with a yaml file -

- -``` -// get the yaml file with --dry-run flag -kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml > nginx-pod.yaml - -// cat nginx-pod.yaml -apiVersion: v1 -kind: Pod -metadata: - creationTimestamp: null - labels: - run: nginx - name: nginx -spec: - containers: - - image: nginx - name: nginx - resources: {} - dnsPolicy: ClusterFirst - restartPolicy: Never -status: {} - -// create a pod -kubectl create -f nginx-pod.yaml -``` -

-
- - -
Output the yaml file of the pod you just created -

- -``` -kubectl get po nginx -o yaml -``` -

-
- - -
Output the yaml file of the pod you just created without the cluster-specific information -

- -``` -kubectl get po nginx -o yaml --export -``` -

-
- - -
Get the complete details of the pod you just created -

- -``` -kubectl describe pod nginx -``` -

-
- - -
Delete the pod you just created -

- -``` -kubectl delete po nginx - -kubectl delete -f nginx-pod.yaml -``` -

-
- - -
Delete the pod you just created without any delay (force delete) -

- -``` -kubectl delete po nginx --grace-period=0 --force -``` -

-
- - -
Create the nginx pod with version 1.17.4 and expose it on port 80 -

- -``` -kubectl run nginx --image=nginx:1.17.4 --restart=Never --port=80 -``` -

-
- - -
Change the Image version to 1.15-alpine for the pod you just created and verify the image version is updated -

- -``` -kubectl set image pod/nginx nginx=nginx:1.15-alpine - -kubectl describe po nginx - -// another way it will open vi editor and change the version -kubeclt edit po nginx - -kubectl describe po nginx -``` -

-
- - -
Change the Image version back to 1.17.1 for the pod you just updated and observe the changes -

- -``` -kubectl set image pod/nginx nginx=nginx:1.17.1 - -kubectl describe po nginx - -kubectl get po nginx -w # watch it -``` -

-
- - -
Check the Image version without the describe command -

- -``` -kubectl get po nginx -o jsonpath='{.spec.containers[].image}{"\n"}' -``` -

-
- - -
Create the nginx pod and execute the simple shell on the pod -

- -``` -// creating a pod -kubectl run nginx --image=nginx --restart=Never - -// exec into the pod -kubectl exec -it nginx /bin/sh -``` -

-
- - -
Get the IP Address of the pod you just created -

- -``` -kubectl get po nginx -o wide -``` -

-
- -
Create a busybox pod and run command ls while creating it and check the logs -

- -``` -kubectl run busybox --image=busybox --restart=Never -- ls - -kubectl logs busybox -``` -

-
- - -
If pod crashed check the previous logs of the pod -

- -``` -kubectl logs busybox -p -``` -

-
- - -
Create a busybox pod with command sleep 3600 -

- -``` -kubectl run busybox --image=busybox --restart=Never -- /bin/sh -c "sleep 3600" -``` -

-
- - -
Check the connection of the nginx pod from the busybox pod -

- -``` -kubectl get po nginx -o wide - -// check the connection -kubectl exec -it busybox -- wget -o- -``` -

-
- - -
Create a busybox pod and echo message ‘How are you’ and delete it manually -

- -``` -kubectl run busybox --image=nginx --restart=Never -it -- echo "How are you" - -kubectl delete po busybox -``` -

-
- - -
Create a busybox pod and echo message ‘How are you’ and have it deleted immediately -

- -``` -// notice the --rm flag -kubectl run busybox --image=nginx --restart=Never -it --rm -- echo "How are you" -``` -

-
- - -
Create an nginx pod and list the pod with different levels of verbosity -

- -``` -// create a pod -kubectl run nginx --image=nginx --restart=Never --port=80 - -// List the pod with different verbosity -kubectl get po nginx --v=7 -kubectl get po nginx --v=8 -kubectl get po nginx --v=9 -``` -

-
- - -
List the nginx pod with custom columns POD_NAME and POD_STATUS -

- -``` -kubectl get po -o=custom-columns="POD_NAME:.metadata.name, POD_STATUS:.status.containerStatuses[].state" -``` -

-
- - -
List all the pods sorted by name -

- -``` -kubectl get pods --sort-by=.metadata.name -``` -

-
- - -
List all the pods sorted by created timestamp -

- -``` -kubectl get pods--sort-by=.metadata.creationTimestamp -``` -

-
+1.
List all the namespaces in the cluster +

+ + ``` + kubectl get namespaces + + kubectl get ns + ``` +

+
+ +2.
List all the pods in all namespaces +

+ + ``` + kubectl get po --all-namespaces + ``` +

+
+ +3.
List all the pods in the particular namespace +

+ + ``` + kubectl get po -n + ``` +

+
+ +4.
List all the services in the particular namespace +

+ + ``` + kubectl get svc -n + ``` +

+
+ +5.
List all the pods showing name and namespace with a json path expression +

+ + ``` + kubectl get pods -o=jsonpath="{.items[*]['metadata.name', 'metadata.namespace']}" + ``` +

+
+ +6.
Create an nginx pod in a default namespace and verify the pod running +

+ + ``` + // creating a pod + kubectl run nginx --image=nginx --restart=Never + + // List the pod + kubectl get po + ``` +

+
+ + +7.
Create the same nginx pod with a yaml file +

+ + ``` + // get the yaml file with --dry-run flag + kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml > nginx-pod.yaml + + // cat nginx-pod.yaml + apiVersion: v1 + kind: Pod + metadata: + creationTimestamp: null + labels: + run: nginx + name: nginx + spec: + containers: + - image: nginx + name: nginx + resources: {} + dnsPolicy: ClusterFirst + restartPolicy: Never + status: {} + + // create a pod + kubectl create -f nginx-pod.yaml + ``` +

+
+ + +8.
Output the yaml file of the pod you just created +

+ + ``` + kubectl get po nginx -o yaml + ``` +

+
+ + +9.
Output the yaml file of the pod you just created without the cluster-specific information +

+ + ``` + kubectl get po nginx -o yaml --export + ``` +

+
+ + +10.
Get the complete details of the pod you just created +

+ + ``` + kubectl describe pod nginx + ``` +

+
+ + +11.
Delete the pod you just created +

+ + ``` + kubectl delete po nginx + + kubectl delete -f nginx-pod.yaml + ``` +

+
+ + +12.
Delete the pod you just created without any delay (force delete) +

+ + ``` + kubectl delete po nginx --grace-period=0 --force + ``` +

+
+ + +13.
Create the nginx pod with version 1.17.4 and expose it on port 80 +

+ + ``` + kubectl run nginx --image=nginx:1.17.4 --restart=Never --port=80 + ``` +

+
+ + +14.
Change the Image version to 1.15-alpine for the pod you just created and verify the image version is updated +

+ + ``` + kubectl set image pod/nginx nginx=nginx:1.15-alpine + + kubectl describe po nginx + + // another way it will open vi editor and change the version + kubeclt edit po nginx + + kubectl describe po nginx + ``` +

+
+ + +15.
Change the Image version back to 1.17.1 for the pod you just updated and observe the changes +

+ + ``` + kubectl set image pod/nginx nginx=nginx:1.17.1 + + kubectl describe po nginx + + kubectl get po nginx -w # watch it + ``` +

+
+ + +16.
Check the Image version without the describe command +

+ + ``` + kubectl get po nginx -o jsonpath='{.spec.containers[].image}{"\n"}' + ``` +

+
+ + +17.
Create the nginx pod and execute the simple shell on the pod +

+ + ``` + // creating a pod + kubectl run nginx --image=nginx --restart=Never + + // exec into the pod + kubectl exec -it nginx /bin/sh + ``` +

+
+ + +18.
Get the IP Address of the pod you just created +

+ + ``` + kubectl get po nginx -o wide + ``` +

+
+ +19.
Create a busybox pod and run command ls while creating it and check the logs +

+ + ``` + kubectl run busybox --image=busybox --restart=Never -- ls + + kubectl logs busybox + ``` +

+
+ + +20.
If pod crashed check the previous logs of the pod +

+ + ``` + kubectl logs busybox -p + ``` +

+
+ + +21.
Create a busybox pod with command sleep 3600 +

+ + ``` + kubectl run busybox --image=busybox --restart=Never -- /bin/sh -c "sleep 3600" + ``` +

+
+ + +22.
Check the connection of the nginx pod from the busybox pod +

+ + ``` + kubectl get po nginx -o wide + + // check the connection + kubectl exec -it busybox -- wget -o- + ``` +

+
+ + +23.
Create a busybox pod and echo message ‘How are you’ and delete it manually +

+ + ``` + kubectl run busybox --image=nginx --restart=Never -it -- echo "How are you" + + kubectl delete po busybox + ``` +

+
+ + +24.
Create a busybox pod and echo message ‘How are you’ and have it deleted immediately +

+ + ``` + // notice the --rm flag + kubectl run busybox --image=nginx --restart=Never -it --rm -- echo "How are you" + ``` +

+
+ + +25.
Create an nginx pod and list the pod with different levels of verbosity +

+ + ``` + // create a pod + kubectl run nginx --image=nginx --restart=Never --port=80 + + // List the pod with different verbosity + kubectl get po nginx --v=7 + kubectl get po nginx --v=8 + kubectl get po nginx --v=9 + ``` +

+
+ + +26.
List the nginx pod with custom columns POD_NAME and POD_STATUS +

+ + ``` + kubectl get po -o=custom-columns="POD_NAME:.metadata.name, POD_STATUS:.status.containerStatuses[].state" + ``` +

+
+ + +27.
List all the pods sorted by name +

+ + ``` + kubectl get pods --sort-by=.metadata.name + ``` +

+
+ + +28.
List all the pods sorted by created timestamp +

+ + ``` + kubectl get pods--sort-by=.metadata.creationTimestamp + ``` +

+
diff --git a/multi-container-pod.md b/multi-container-pod.md index d09e50c..1439677 100644 --- a/multi-container-pod.md +++ b/multi-container-pod.md @@ -6,164 +6,164 @@ ## Questions -
Create a Pod with three busy box containers with commands “ls; sleep 3600;”, “echo Hello World; sleep 3600;” and “echo this is the third container; sleep 3600” respectively and check the status -

- -``` -// first create single container pod with dry run flag -kubectl run busybox --image=busybox --restart=Never --dry-run -o yaml -- bin/sh -c "sleep 3600; ls" > multi-container.yaml - -// edit the pod like below - -apiVersion: v1 -kind: Pod -metadata: - creationTimestamp: null - labels: - run: busybox - name: busybox -spec: - containers: - - args: - - bin/sh - - -c - - ls; sleep 3600 - image: busybox - name: busybox1 - resources: {} - - args: - - bin/sh - - -c - - echo Hello world; sleep 3600 - image: busybox - name: busybox2 - resources: {} - - args: - - bin/sh - - -c - - echo this is third container; sleep 3600 - image: busybox - name: busybox3 - resources: {} - dnsPolicy: ClusterFirst - restartPolicy: Never -status: {} - -// create it -kubectl create -f multi-container.yaml - -kubectl get po busybox -``` -

-
- -
Check the logs of each container that you just created -

- -``` -kubectl logs busybox -c busybox1 -kubectl logs busybox -c busybox2 -kubectl logs busybox -c busybox3 -``` -

-
- -
Check the previous logs of the second container busybox2 if any -

- -``` -kubectl logs busybox -c busybox2 --previous -``` -

-
- -
Run command ls in the third container busybox3 of the above pod -

- -``` -kubectl exec busybox -c busybox3 -- ls -``` -

-
- -
Show metrics of the above pod containers and puts them into the file.log and verify -

- -``` -kubectl top pod busybox --containers - -// putting them into file -kubectl top pod busybox --containers > file.log -cat file.log -``` -

-
- - -
Create a Pod with main container busybox and which executes this “while true; do echo ‘Hi I am from Main container’ >> /var/log/index.html; sleep 5; done” and with sidecar container with nginx image which exposes on port 80. Use emptyDir Volume and mount this volume on path /var/log for busybox and on path /usr/share/nginx/html for nginx container. Verify both containers are running. -

- -``` -// create an initial yaml file with this -kubectl run multi-cont-pod --image=busbox --restart=Never --dry-run -o yaml > multi-container.yaml - -// edit the yml as below and create it -apiVersion: v1 -kind: Pod -metadata: - creationTimestamp: null - labels: - run: multi-cont-pod - name: multi-cont-pod -spec: - volumes: - - name: var-logs - emptyDir: {} - containers: - - image: busybox - command: ["/bin/sh"] - args: ["-c", "while true; do echo 'Hi I am from Main container' >> /var/log/index.html; sleep 5;done"] - name: main-container - resources: {} - volumeMounts: - - name: var-logs - mountPath: /var/log - - image: nginx - name: sidecar-container - resources: {} - ports: - - containerPort: 80 - volumeMounts: - - name: var-logs - mountPath: /usr/share/nginx/html - dnsPolicy: ClusterFirst - restartPolicy: Never -status: {} - -kubectl create -f multi-container.yaml - -kubectl get po multi-cont-pod -``` -

-
- - -
Exec into both containers and verify that main.txt exist and query the main.txt from sidecar container with curl localhost -

- -``` -// exec into main container -kubectl exec -it multi-cont-pod -c main-container -- sh -cat /var/log/main.txt - -// exec into sidecar container -kubectl exec -it multi-cont-pod -c sidecar-container -- sh -cat /usr/share/nginx/html/index.html - -// install curl and get default page -kubectl exec -it multi-cont-pod -c sidecar-container -- sh -# apt-get update && apt-get install -y curl -# curl localhost -``` -

-
+1.
Create a Pod with three busy box containers with commands “ls; sleep 3600;”, “echo Hello World; sleep 3600;” and “echo this is the third container; sleep 3600” respectively and check the status +

+ + ``` + // first create single container pod with dry run flag + kubectl run busybox --image=busybox --restart=Never --dry-run -o yaml -- bin/sh -c "sleep 3600; ls" > multi-container.yaml + + // edit the pod like below + + apiVersion: v1 + kind: Pod + metadata: + creationTimestamp: null + labels: + run: busybox + name: busybox + spec: + containers: + - args: + - bin/sh + - -c + - ls; sleep 3600 + image: busybox + name: busybox1 + resources: {} + - args: + - bin/sh + - -c + - echo Hello world; sleep 3600 + image: busybox + name: busybox2 + resources: {} + - args: + - bin/sh + - -c + - echo this is third container; sleep 3600 + image: busybox + name: busybox3 + resources: {} + dnsPolicy: ClusterFirst + restartPolicy: Never + status: {} + + // create it + kubectl create -f multi-container.yaml + + kubectl get po busybox + ``` +

+
+ +2.
Check the logs of each container that you just created +

+ + ``` + kubectl logs busybox -c busybox1 + kubectl logs busybox -c busybox2 + kubectl logs busybox -c busybox3 + ``` +

+
+ +3.
Check the previous logs of the second container busybox2 if any +

+ + ``` + kubectl logs busybox -c busybox2 --previous + ``` +

+
+ +4.
Run command ls in the third container busybox3 of the above pod +

+ + ``` + kubectl exec busybox -c busybox3 -- ls + ``` +

+
+ +5.
Show metrics of the above pod containers and puts them into the file.log and verify +

+ + ``` + kubectl top pod busybox --containers + + // putting them into file + kubectl top pod busybox --containers > file.log + cat file.log + ``` +

+
+ + +6.
Create a Pod with main container busybox and which executes this “while true; do echo ‘Hi I am from Main container’ >> /var/log/index.html; sleep 5; done” and with sidecar container with nginx image which exposes on port 80. Use emptyDir Volume and mount this volume on path /var/log for busybox and on path /usr/share/nginx/html for nginx container. Verify both containers are running. +

+ + ``` + // create an initial yaml file with this + kubectl run multi-cont-pod --image=busbox --restart=Never --dry-run -o yaml > multi-container.yaml + + // edit the yml as below and create it + apiVersion: v1 + kind: Pod + metadata: + creationTimestamp: null + labels: + run: multi-cont-pod + name: multi-cont-pod + spec: + volumes: + - name: var-logs + emptyDir: {} + containers: + - image: busybox + command: ["/bin/sh"] + args: ["-c", "while true; do echo 'Hi I am from Main container' >> /var/log/index.html; sleep 5;done"] + name: main-container + resources: {} + volumeMounts: + - name: var-logs + mountPath: /var/log + - image: nginx + name: sidecar-container + resources: {} + ports: + - containerPort: 80 + volumeMounts: + - name: var-logs + mountPath: /usr/share/nginx/html + dnsPolicy: ClusterFirst + restartPolicy: Never + status: {} + + kubectl create -f multi-container.yaml + + kubectl get po multi-cont-pod + ``` +

+
+ + +7.
Exec into both containers and verify that main.txt exist and query the main.txt from sidecar container with curl localhost +

+ + ``` + // exec into main container + kubectl exec -it multi-cont-pod -c main-container -- sh + cat /var/log/main.txt + + // exec into sidecar container + kubectl exec -it multi-cont-pod -c sidecar-container -- sh + cat /usr/share/nginx/html/index.html + + // install curl and get default page + kubectl exec -it multi-cont-pod -c sidecar-container -- sh + # apt-get update && apt-get install -y curl + # curl localhost + ``` +

+
diff --git a/observability.md b/observability.md index 5e45358..05c8430 100644 --- a/observability.md +++ b/observability.md @@ -9,287 +9,287 @@ ## Questions -
Create an nginx pod with containerPort 80 and it should only receive traffic only it checks the endpoint / on port 80 and verify and delete the pod -

- -``` -kubectl run nginx --image=nginx --restart=Never --port=80 --dry-run -o yaml > nginx-pod.yaml - -// add the readinessProbe section and create -apiVersion: v1 -kind: Pod -metadata: - creationTimestamp: null - labels: - run: nginx - name: nginx -spec: - containers: - - image: nginx - name: nginx - ports: - - containerPort: 80 - readinessProbe: - httpGet: - path: / - port: 80 - resources: {} - dnsPolicy: ClusterFirst - restartPolicy: Never -status: {} - -kubectl create -f nginx-pod.yaml - -// verify -kubectl describe pod nginx | grep -i readiness -kubectl delete po nginx -``` -

-
- - -
Create an nginx pod with containerPort 80 and it should check the pod running at endpoint / healthz on port 80 and verify and delete the pod -

- -``` -kubectl run nginx --image=nginx --restart=Never --port=80 --dry-run -o yaml > nginx-pod.yaml - -// add the livenessProbe section and create -apiVersion: v1 -kind: Pod -metadata: - creationTimestamp: null - labels: - run: nginx - name: nginx -spec: - containers: - - image: nginx - name: nginx - ports: - - containerPort: 80 - livenessProbe: - httpGet: - path: /healthz - port: 80 - resources: {} - dnsPolicy: ClusterFirst - restartPolicy: Never -status: {} - -kubectl create -f nginx-pod.yaml - -// verify -kubectl describe pod nginx | grep -i readiness -kubectl delete po nginx -``` -

-
- - -
Create an nginx pod with containerPort 80 and it should check the pod running at endpoint /healthz on port 80 and it should only receive traffic only it checks the endpoint / on port 80. verify the pod -

- -``` -kubectl run nginx --image=nginx --restart=Never --port=80 --dry-run -o yaml > nginx-pod.yaml - -// add the livenessProbe and readiness section and create -apiVersion: v1 -kind: Pod -metadata: - creationTimestamp: null - labels: - run: nginx - name: nginx -spec: - containers: - - image: nginx - name: nginx - ports: - - containerPort: 80 - livenessProbe: - httpGet: - path: /healthz - port: 80 - readinessProbe: - httpGet: - path: / - port: 80 - resources: {} - dnsPolicy: ClusterFirst - restartPolicy: Never -status: {} - -kubectl create -f nginx-pod.yaml - -// verify -kubectl describe pod nginx | grep -i readiness -kubectl describe pod nginx | grep -i liveness -``` -

-
- - -
Check what all are the options that we can configure with readiness and liveness probes -

- -``` -kubectl explain Pod.spec.containers.livenessProbe -kubectl explain Pod.spec.containers.readinessProbe -``` -

-
- - -
Create the pod nginx with the above liveness and readiness probes so that it should wait for 20 seconds before it checks liveness and readiness probes and it should check every 25 seconds. -

- -``` -// nginx-pod.yaml - -apiVersion: v1 -kind: Pod -metadata: - creationTimestamp: null - labels: - run: nginx - name: nginx -spec: - containers: - - image: nginx - name: nginx - ports: - - containerPort: 80 - livenessProbe: - initialDelaySeconds: 20 - periodSeconds: 25 - httpGet: - path: /healthz - port: 80 - readinessProbe: - initialDelaySeconds: 20 - periodSeconds: 25 - httpGet: - path: / - port: 80 - resources: {} - dnsPolicy: ClusterFirst - restartPolicy: Never -status: {} - -kubectl create -f nginx-pod.yaml -``` -

-
- - -
Create a busybox pod with this command “echo I am from busybox pod; sleep 3600;” and verify the logs -

- -``` -kubectl run busybox --image=busybox --restart=Never -- /bin/sh -c "echo I am from busybox pod; sleep 3600;" - -kubectl logs busybox -``` -

-
- - -
copy the logs of the above pod to the busybox-logs.txt and verify -

- -``` -kubectl logs busybox > busybox-logs.txt - -cat busybox-logs.txt -``` -

-
- - -
List all the events sorted by timestamp and put them into file.log and verify -

- -``` -kubectl get events --sort-by=.metadata.creationTimestamp - -// putting them into file.log -kubectl get events --sort-by=.metadata.creationTimestamp > file.log - -cat file.log -``` -

-
- - -
Create a pod with an image alpine which executes this command ”while true; do echo ‘Hi I am from alpine’; sleep 5; done” and verify and follow the logs of the pod -

- -``` -// create the pod -kubectl run hello --image=alpine --restart=Never -- /bin/sh -c "while true; do echo 'Hi I am from Alpine'; sleep 5;done" - -// verify and follow the logs -kubectl logs --follow hello -``` -

-
- - -
Create the pod with this kubectl create -f https://gist.githubusercontent.com/bbachi/212168375b39e36e2e2984c097167b00/raw/1fd63509c3ae3a3d3da844640fb4cca744543c1c/not-running.yml. The pod is not in the running state. Debug it. -

- -``` -// create the pod -kubectl create -f https://gist.githubusercontent.com/bbachi/212168375b39e36e2e2984c097167b00/raw/1fd63509c3ae3a3d3da844640fb4cca744543c1c/not-running.yml - -// get the pod -kubectl get pod not-running -kubectl describe po not-running - -// it clearly says ImagePullBackOff something wrong with image -kubectl edit pod not-running // it will open vim editor - or -kubectl set image pod/not-running not-running=nginx -``` -

-
- - -
This following yaml creates 4 namespaces and 4 pods. One of the pod in one of the namespaces are not in the running state. Debug and fix it. `https://gist.githubusercontent.com/bbachi/1f001f10337234d46806929d12245397/raw/84b7295fb077f15de979fec5b3f7a13fc69c6d83/problem-pod.yaml` -

- -``` -kubectl create -f https://gist.githubusercontent.com/bbachi/1f001f10337234d46806929d12245397/raw/84b7295fb077f15de979fec5b3f7a13fc69c6d83/problem-pod.yaml - -// get all the pods in all namespaces -kubectl get po --all-namespaces - -// find out which pod is not running -kubectl get po -n namespace2 - -// update the image -kubectl set image pod/pod2 pod2=nginx -n namespace2 - -// verify again -kubectl get po -n namespace2 -``` -

-
- - -
Get the memory and CPU usage of all the pods and find out top 3 pods which have the highest usage and put them into the cpu-usage.txt file -

- -``` -// get the top 3 hungry pods -kubectl top pod --all-namespaces | sort --reverse --key 3 --numeric | head -3 - -// putting into file -kubectl top pod --all-namespaces | sort --reverse --key 3 --numeric | head -3 > cpu-usage.txt - -// verify -cat cpu-usage.txt -``` -

-
+1.
Create an nginx pod with containerPort 80 and it should only receive traffic only it checks the endpoint / on port 80 and verify and delete the pod +

+ + ``` + kubectl run nginx --image=nginx --restart=Never --port=80 --dry-run -o yaml > nginx-pod.yaml + + // add the readinessProbe section and create + apiVersion: v1 + kind: Pod + metadata: + creationTimestamp: null + labels: + run: nginx + name: nginx + spec: + containers: + - image: nginx + name: nginx + ports: + - containerPort: 80 + readinessProbe: + httpGet: + path: / + port: 80 + resources: {} + dnsPolicy: ClusterFirst + restartPolicy: Never + status: {} + + kubectl create -f nginx-pod.yaml + + // verify + kubectl describe pod nginx | grep -i readiness + kubectl delete po nginx + ``` +

+
+ + +2.
Create an nginx pod with containerPort 80 and it should check the pod running at endpoint / healthz on port 80 and verify and delete the pod +

+ + ``` + kubectl run nginx --image=nginx --restart=Never --port=80 --dry-run -o yaml > nginx-pod.yaml + + // add the livenessProbe section and create + apiVersion: v1 + kind: Pod + metadata: + creationTimestamp: null + labels: + run: nginx + name: nginx + spec: + containers: + - image: nginx + name: nginx + ports: + - containerPort: 80 + livenessProbe: + httpGet: + path: /healthz + port: 80 + resources: {} + dnsPolicy: ClusterFirst + restartPolicy: Never + status: {} + + kubectl create -f nginx-pod.yaml + + // verify + kubectl describe pod nginx | grep -i readiness + kubectl delete po nginx + ``` +

+
+ + +3.
Create an nginx pod with containerPort 80 and it should check the pod running at endpoint /healthz on port 80 and it should only receive traffic only it checks the endpoint / on port 80. verify the pod +

+ + ``` + kubectl run nginx --image=nginx --restart=Never --port=80 --dry-run -o yaml > nginx-pod.yaml + + // add the livenessProbe and readiness section and create + apiVersion: v1 + kind: Pod + metadata: + creationTimestamp: null + labels: + run: nginx + name: nginx + spec: + containers: + - image: nginx + name: nginx + ports: + - containerPort: 80 + livenessProbe: + httpGet: + path: /healthz + port: 80 + readinessProbe: + httpGet: + path: / + port: 80 + resources: {} + dnsPolicy: ClusterFirst + restartPolicy: Never + status: {} + + kubectl create -f nginx-pod.yaml + + // verify + kubectl describe pod nginx | grep -i readiness + kubectl describe pod nginx | grep -i liveness + ``` +

+
+ + +4.
Check what all are the options that we can configure with readiness and liveness probes +

+ + ``` + kubectl explain Pod.spec.containers.livenessProbe + kubectl explain Pod.spec.containers.readinessProbe + ``` +

+
+ + +5.
Create the pod nginx with the above liveness and readiness probes so that it should wait for 20 seconds before it checks liveness and readiness probes and it should check every 25 seconds. +

+ + ``` + // nginx-pod.yaml + + apiVersion: v1 + kind: Pod + metadata: + creationTimestamp: null + labels: + run: nginx + name: nginx + spec: + containers: + - image: nginx + name: nginx + ports: + - containerPort: 80 + livenessProbe: + initialDelaySeconds: 20 + periodSeconds: 25 + httpGet: + path: /healthz + port: 80 + readinessProbe: + initialDelaySeconds: 20 + periodSeconds: 25 + httpGet: + path: / + port: 80 + resources: {} + dnsPolicy: ClusterFirst + restartPolicy: Never + status: {} + + kubectl create -f nginx-pod.yaml + ``` +

+
+ + +6.
Create a busybox pod with this command “echo I am from busybox pod; sleep 3600;” and verify the logs +

+ + ``` + kubectl run busybox --image=busybox --restart=Never -- /bin/sh -c "echo I am from busybox pod; sleep 3600;" + + kubectl logs busybox + ``` +

+
+ + +7.
copy the logs of the above pod to the busybox-logs.txt and verify +

+ + ``` + kubectl logs busybox > busybox-logs.txt + + cat busybox-logs.txt + ``` +

+
+ + +8.
List all the events sorted by timestamp and put them into file.log and verify +

+ + ``` + kubectl get events --sort-by=.metadata.creationTimestamp + + // putting them into file.log + kubectl get events --sort-by=.metadata.creationTimestamp > file.log + + cat file.log + ``` +

+
+ + +9.
Create a pod with an image alpine which executes this command ”while true; do echo ‘Hi I am from alpine’; sleep 5; done” and verify and follow the logs of the pod +

+ + ``` + // create the pod + kubectl run hello --image=alpine --restart=Never -- /bin/sh -c "while true; do echo 'Hi I am from Alpine'; sleep 5;done" + + // verify and follow the logs + kubectl logs --follow hello + ``` +

+
+ + +10.
Create the pod with this kubectl create -f https://gist.githubusercontent.com/bbachi/212168375b39e36e2e2984c097167b00/raw/1fd63509c3ae3a3d3da844640fb4cca744543c1c/not-running.yml. The pod is not in the running state. Debug it. +

+ + ``` + // create the pod + kubectl create -f https://gist.githubusercontent.com/bbachi/212168375b39e36e2e2984c097167b00/raw/1fd63509c3ae3a3d3da844640fb4cca744543c1c/not-running.yml + + // get the pod + kubectl get pod not-running + kubectl describe po not-running + + // it clearly says ImagePullBackOff something wrong with image + kubectl edit pod not-running // it will open vim editor + or + kubectl set image pod/not-running not-running=nginx + ``` +

+
+ + +11.
This following yaml creates 4 namespaces and 4 pods. One of the pod in one of the namespaces are not in the running state. Debug and fix it. `https://gist.githubusercontent.com/bbachi/1f001f10337234d46806929d12245397/raw/84b7295fb077f15de979fec5b3f7a13fc69c6d83/problem-pod.yaml` +

+ + ``` + kubectl create -f https://gist.githubusercontent.com/bbachi/1f001f10337234d46806929d12245397/raw/84b7295fb077f15de979fec5b3f7a13fc69c6d83/problem-pod.yaml + + // get all the pods in all namespaces + kubectl get po --all-namespaces + + // find out which pod is not running + kubectl get po -n namespace2 + + // update the image + kubectl set image pod/pod2 pod2=nginx -n namespace2 + + // verify again + kubectl get po -n namespace2 + ``` +

+
+ + +12.
Get the memory and CPU usage of all the pods and find out top 3 pods which have the highest usage and put them into the cpu-usage.txt file +

+ + ``` + // get the top 3 hungry pods + kubectl top pod --all-namespaces | sort --reverse --key 3 --numeric | head -3 + + // putting into file + kubectl top pod --all-namespaces | sort --reverse --key 3 --numeric | head -3 > cpu-usage.txt + + // verify + cat cpu-usage.txt + ``` +

+
diff --git a/pod-design.md b/pod-design.md index 628d33b..81889ae 100644 --- a/pod-design.md +++ b/pod-design.md @@ -10,832 +10,832 @@ ## Questions -
Get the pods with label information -

- -``` -kubectl get pods --show-labels -``` -

-
- - -
Create 5 nginx pods in which two of them is labeled env=prod and three of them is labeled env=dev -

- -``` -kubectl run nginx-dev1 --image=nginx --restart=Never --labels=env=dev -kubectl run nginx-dev2 --image=nginx --restart=Never --labels=env=dev -kubectl run nginx-dev3 --image=nginx --restart=Never --labels=env=dev -kubectl run nginx-prod1 --image=nginx --restart=Never --labels=env=prod -kubectl run nginx-prod2 --image=nginx --restart=Never --labels=env=prod -``` -

-
- - -
Verify all the pods are created with correct labels -

- -``` -kubeclt get pods --show-labels -``` -

-
- -
Get the pods with label env=dev -

- -``` -kubectl get pods -l env=dev -``` -

-
- -
Get the pods with label env=dev and also output the labels -

- -``` -kubectl get pods -l env=dev --show-labels -``` -

-
- -
Get the pods with label env=prod -

- -``` -kubectl get pods -l env=prod -``` -

-
- -
Get the pods with label env=prod and also output the labels -

- -``` -kubectl get pods -l env=prod --show-labels -``` -

-
- - -
Get the pods with label env -

- -``` -kubectl get pods -L env -``` -

-
- - -
Get the pods with labels env=dev and env=prod -

- -``` -kubectl get pods -l 'env in (dev,prod)' -``` -

-
- - -
Get the pods with labels env=dev and env=prod and output the labels as well -

- -``` -kubectl get pods -l 'env in (dev,prod)' --show-labels -``` -

-
- - -
Change the label for one of the pod to env=uat and list all the pods to verify -

- -``` -kubectl label pod/nginx-dev3 env=uat --overwrite - -kubectl get pods --show-labels -``` -

-
- - -
Remove the labels for the pods that we created now and verify all the labels are removed -

- -``` -kubectl label pod nginx-dev{1..3} env- -kubectl label pod nginx-prod{1..2} env- - -kubectl get po --show-labels -``` -

-
- - -
Let’s add the label app=nginx for all the pods and verify -

- -``` -kubectl label pod nginx-dev{1..3} app=nginx -kubectl label pod nginx-prod{1..2} app=nginx - -kubectl get po --show-labels -``` -

-
- - -
Get all the nodes with labels (if using minikube you would get only master node) -

- -``` -kubectl get nodes --show-labels -``` -

-
- - -
Label the node (minikube if you are using) nodeName=nginxnode -

- -``` -kubectl label node minikube nodeName=nginxnode -``` -

-
- - -
Create a Pod that will be deployed on this node with the label nodeName=nginxnode -

- -``` -kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml > pod.yaml - -// add the nodeSelector like below and create the pod - -apiVersion: v1 -kind: Pod -metadata: - creationTimestamp: null - labels: - run: nginx - name: nginx -spec: - nodeSelector: - nodeName: nginxnode - containers: - - image: nginx - name: nginx - resources: {} - dnsPolicy: ClusterFirst - restartPolicy: Never -status: {} - -kubectl create -f pod.yaml -``` -

-
- - -
Verify the pod that it is scheduled with the node selector -

- -``` -kubectl describe po nginx | grep Node-Selectors -``` -

-
- - -
Verify the pod nginx that we just created has this label -

- -``` -kubectl describe po nginx | grep Labels -``` -

-
- - -
Annotate the pods with name=webapp -

- -``` -kubectl annotate pod nginx-dev{1..3} name=webapp -kubectl annotate pod nginx-prod{1..2} name=webapp -``` -

-
- - -
Verify the pods that have been annotated correctly -

- -``` -kubectl describe po nginx-dev{1..3} | grep -i annotations -kubectl describe po nginx-prod{1..2} | grep -i annotations -``` -

-
- - - -
Remove the annotations on the pods and verify -

- -``` -kubectl annotate pod nginx-dev{1..3} name- -kubectl annotate pod nginx-prod{1..2} name- - -kubectl describe po nginx-dev{1..3} | grep -i annotations -kubectl describe po nginx-prod{1..2} | grep -i annotations -``` -

-
- - -
Remove all the pods that we created so far -

- -``` -kubectl delete po --all -``` -

-
- - -
Create a deployment called webapp with image nginx with 5 replicas -

- -``` -kubectl create deploy webapp --image=nginx --dry-run -o yaml > webapp.yaml - -// change the replicas to 5 in the yaml and create it - -apiVersion: apps/v1 -kind: Deployment -metadata: - creationTimestamp: null - labels: - app: webapp - name: webapp -spec: - replicas: 5 - selector: - matchLabels: - app: webapp - strategy: {} - template: +1.

Get the pods with label information +

+ + ``` + kubectl get pods --show-labels + ``` +

+
+ + +2.
Create 5 nginx pods in which two of them is labeled env=prod and three of them is labeled env=dev +

+ + ``` + kubectl run nginx-dev1 --image=nginx --restart=Never --labels=env=dev + kubectl run nginx-dev2 --image=nginx --restart=Never --labels=env=dev + kubectl run nginx-dev3 --image=nginx --restart=Never --labels=env=dev + kubectl run nginx-prod1 --image=nginx --restart=Never --labels=env=prod + kubectl run nginx-prod2 --image=nginx --restart=Never --labels=env=prod + ``` +

+
+ + +3.
Verify all the pods are created with correct labels +

+ + ``` + kubeclt get pods --show-labels + ``` +

+
+ +4.
Get the pods with label env=dev +

+ + ``` + kubectl get pods -l env=dev + ``` +

+
+ +5.
Get the pods with label env=dev and also output the labels +

+ + ``` + kubectl get pods -l env=dev --show-labels + ``` +

+
+ +6.
Get the pods with label env=prod +

+ + ``` + kubectl get pods -l env=prod + ``` +

+
+ +7.
Get the pods with label env=prod and also output the labels +

+ + ``` + kubectl get pods -l env=prod --show-labels + ``` +

+
+ + +8.
Get the pods with label env +

+ + ``` + kubectl get pods -L env + ``` +

+
+ + +9.
Get the pods with labels env=dev and env=prod +

+ + ``` + kubectl get pods -l 'env in (dev,prod)' + ``` +

+
+ + +10.
Get the pods with labels env=dev and env=prod and output the labels as well +

+ + ``` + kubectl get pods -l 'env in (dev,prod)' --show-labels + ``` +

+
+ + +11.
Change the label for one of the pod to env=uat and list all the pods to verify +

+ + ``` + kubectl label pod/nginx-dev3 env=uat --overwrite + + kubectl get pods --show-labels + ``` +

+
+ + +12.
Remove the labels for the pods that we created now and verify all the labels are removed +

+ + ``` + kubectl label pod nginx-dev{1..3} env- + kubectl label pod nginx-prod{1..2} env- + + kubectl get po --show-labels + ``` +

+
+ + +13.
Let’s add the label app=nginx for all the pods and verify +

+ + ``` + kubectl label pod nginx-dev{1..3} app=nginx + kubectl label pod nginx-prod{1..2} app=nginx + + kubectl get po --show-labels + ``` +

+
+ + +14.
Get all the nodes with labels (if using minikube you would get only master node) +

+ + ``` + kubectl get nodes --show-labels + ``` +

+
+ + +15.
Label the node (minikube if you are using) nodeName=nginxnode +

+ + ``` + kubectl label node minikube nodeName=nginxnode + ``` +

+
+ + +16.
Create a Pod that will be deployed on this node with the label nodeName=nginxnode +

+ + ``` + kubectl run nginx --image=nginx --restart=Never --dry-run -o yaml > pod.yaml + + // add the nodeSelector like below and create the pod + + apiVersion: v1 + kind: Pod metadata: creationTimestamp: null labels: - app: webapp + run: nginx + name: nginx spec: + nodeSelector: + nodeName: nginxnode containers: - image: nginx name: nginx resources: {} -status: {} - -kubectl create -f webapp.yaml -``` -

-
- - -
Get the deployment you just created with labels -

- -``` -kubectl get deploy webapp --show-labels -``` -

-
- - -
Output the yaml file of the deployment you just created -

- -``` -kubectl get deploy webapp -o yaml -``` -

-
- - -
Get the pods of this deployment -

- -``` -// get the label of the deployment -kubectl get deploy --show-labels - -// get the pods with that label -kubectl get pods -l app=webapp -``` -

-
- - -
Scale the deployment from 5 replicas to 20 replicas and verify -

- -``` -kubectl scale deploy webapp --replicas=20 - -kubectl get po -l app=webapp -``` -

-
- - -
Get the deployment rollout status -

- -``` -kubectl rollout status deploy webapp -``` -

-
- - -
Get the replicaset that created with this deployment -

- -``` -kubectl get rs -l app=webapp -``` -

-
- - -
Get the yaml of the replicaset and pods of this deployment -

- -``` -kubectl get rs -l app=webapp -o yaml - -kubectl get po -l app=webapp -o yaml -``` -

-
- - -
Delete the deployment you just created and watch all the pods are also being deleted -

- -``` -kubectl delete deploy webapp - -kubectl get po -l app=webapp -w -``` -

-
- - -
Create a deployment of webapp with image nginx:1.17.1 with container port 80 and verify the image version -

- -``` -kubectl create deploy webapp --image=nginx:1.17.1 --dry-run -o yaml > webapp.yaml - -// add the port section and create the deployment - -apiVersion: apps/v1 -kind: Deployment -metadata: - creationTimestamp: null - labels: - app: webapp - name: webapp -spec: - replicas: 1 - selector: - matchLabels: - app: webapp - strategy: {} - template: + dnsPolicy: ClusterFirst + restartPolicy: Never + status: {} + + kubectl create -f pod.yaml + ``` +

+
+ + +17.
Verify the pod that it is scheduled with the node selector +

+ + ``` + kubectl describe po nginx | grep Node-Selectors + ``` +

+
+ + +18.
Verify the pod nginx that we just created has this label +

+ + ``` + kubectl describe po nginx | grep Labels + ``` +

+
+ + +19.
Annotate the pods with name=webapp +

+ + ``` + kubectl annotate pod nginx-dev{1..3} name=webapp + kubectl annotate pod nginx-prod{1..2} name=webapp + ``` +

+
+ + +20.
Verify the pods that have been annotated correctly +

+ + ``` + kubectl describe po nginx-dev{1..3} | grep -i annotations + kubectl describe po nginx-prod{1..2} | grep -i annotations + ``` +

+
+ + + +21.
Remove the annotations on the pods and verify +

+ + ``` + kubectl annotate pod nginx-dev{1..3} name- + kubectl annotate pod nginx-prod{1..2} name- + + kubectl describe po nginx-dev{1..3} | grep -i annotations + kubectl describe po nginx-prod{1..2} | grep -i annotations + ``` +

+
+ + +22.
Remove all the pods that we created so far +

+ + ``` + kubectl delete po --all + ``` +

+
+ + +23.
Create a deployment called webapp with image nginx with 5 replicas +

+ + ``` + kubectl create deploy webapp --image=nginx --dry-run -o yaml > webapp.yaml + + // change the replicas to 5 in the yaml and create it + + apiVersion: apps/v1 + kind: Deployment metadata: creationTimestamp: null labels: app: webapp + name: webapp spec: - containers: - - image: nginx:1.17.1 - name: nginx - ports: - - containerPort: 80 - resources: {} -status: {} - -kubectl create -f webapp.yaml - -// verify -kubectl describe deploy webapp | grep Image -``` -

-
- - -
Update the deployment with the image version 1.17.4 and verify -

- -``` -kubectl set image deploy/webapp nginx=nginx:1.17.4 - -kubectl describe deploy webapp | grep Image -``` -

-
- - -
Check the rollout history and make sure everything is ok after the update -

- -``` -kubectl rollout history deploy webapp - -kubectl get deploy webapp --show-labels -kubectl get rs -l app=webapp -kubectl get po -l app=webapp -``` -

-
- - -
Undo the deployment to the previous version 1.17.1 and verify Image has the previous version -

- -``` -kubectl rollout undo deploy webapp - -kubectl describe deploy webapp | grep Image -``` -

-
- - - -
Update the deployment with the image version 1.16.1 and verify the image and also check the rollout history -

- -``` -kubectl set image deploy/webapp nginx=nginx:1.16.1 - -kubectl describe deploy webapp | grep Image - -kubectl rollout history deploy webapp -``` -

-
- - - -
Update the deployment to the Image 1.17.1 and verify everything is ok -

- -``` -kubectl rollout undo deploy webapp --to-revision=3 - -kubectl describe deploy webapp | grep Image - -kubectl rollout status deploy webapp -``` -

-
- - -
Update the deployment with the wrong image version 1.100 and verify something is wrong with the deployment -

- -``` -kubectl set image deploy/webapp nginx=nginx:1.100 - -kubectl rollout status deploy webapp (still pending state) - -kubectl get pods (ImagePullErr) -``` -

-
- - -
Undo the deployment with the previous version and verify everything is Ok -

- -``` -kubectl rollout undo deploy webapp -kubectl rollout status deploy webapp - -kubectl get pods -``` -

-
- - -
Check the history of the specific revision of that deployment -

- -``` -kubectl rollout history deploy webapp --revision=7 -``` -

-
- - - -
Pause the rollout of the deployment -

- -``` -kubectl rollout pause deploy webapp -``` -

-
- - -
Update the deployment with the image version latest and check the history and verify nothing is going on -

- -``` -kubectl set image deploy/webapp nginx=nginx:latest - -kubectl rollout history deploy webapp (No new revision) -``` -

-
- - - -
Resume the rollout of the deployment -

- -``` -kubectl rollout resume deploy webapp -``` -

-
- - -
Check the rollout history and verify it has the new version - -

- -``` -kubectl rollout history deploy webapp - -kubectl rollout history deploy webapp --revision=9 -``` -

-
- - -
Apply the autoscaling to this deployment with minimum 10 and maximum 20 replicas and target CPU of 85% and verify hpa is created and replicas are increased to 10 from 1 - -

- -``` -kubectl autoscale deploy webapp --min=10 --max=20 --cpu-percent=85 - -kubectl get hpa - -kubectl get pod -l app=webapp -``` -

-
- - -
Clean the cluster by deleting deployment and hpa you just created -

- -``` -kubectl delete deploy webapp - -kubectl delete hpa webapp -``` -

-
- - -
Create a Job with an image node which prints node version and also verifies there is a pod created for this job -

- -``` -kubectl create job nodeversion --image=node -- node -v - -kubectl get job -w -kubectl get pod -``` -

-
- - - -
Get the logs of the job just created -

- -``` -kubectl logs // created from the job -``` -

-
- - - -
Output the yaml file for the Job with the image busybox which echos “Hello I am from job” -

- -``` -kubectl create job hello-job --image=busybox --dry-run -o yaml -- echo "Hello I am from job" -``` -

-
- - -
Copy the above YAML file to hello-job.yaml file and create the job -

- -``` -kubectl create job hello-job --image=busybox --dry-run -o yaml -- echo "Hello I am from job" > hello-job.yaml - -kubectl create -f hello-job.yaml -``` -

-
- - -
Verify the job and the associated pod is created and check the logs as well -

- -``` -kubectl get job -kubectl get po - -kubectl logs hello-job-* -``` -

-
- - - -
Delete the job we just created -

- -``` -kubectl delete job hello-job -``` -

-
- - -
Create the same job and make it run 10 times one after one -

- -``` -kubectl create job hello-job --image=busybox --dry-run -o yaml -- echo "Hello I am from job" > hello-job.yaml - -// edit the yaml file to add completions: 10 - -apiVersion: batch/v1 -kind: Job -metadata: - creationTimestamp: null - name: hello-job -spec: - completions: 10 - template: + replicas: 5 + selector: + matchLabels: + app: webapp + strategy: {} + template: + metadata: + creationTimestamp: null + labels: + app: webapp + spec: + containers: + - image: nginx + name: nginx + resources: {} + status: {} + + kubectl create -f webapp.yaml + ``` +

+
+ + +24.
Get the deployment you just created with labels +

+ + ``` + kubectl get deploy webapp --show-labels + ``` +

+
+ + +25.
Output the yaml file of the deployment you just created +

+ + ``` + kubectl get deploy webapp -o yaml + ``` +

+
+ + +26.
Get the pods of this deployment +

+ + ``` + // get the label of the deployment + kubectl get deploy --show-labels + + // get the pods with that label + kubectl get pods -l app=webapp + ``` +

+
+ + +27.
Scale the deployment from 5 replicas to 20 replicas and verify +

+ + ``` + kubectl scale deploy webapp --replicas=20 + + kubectl get po -l app=webapp + ``` +

+
+ + +28.
Get the deployment rollout status +

+ + ``` + kubectl rollout status deploy webapp + ``` +

+
+ + +29.
Get the replicaset that created with this deployment +

+ + ``` + kubectl get rs -l app=webapp + ``` +

+
+ + +30.
Get the yaml of the replicaset and pods of this deployment +

+ + ``` + kubectl get rs -l app=webapp -o yaml + + kubectl get po -l app=webapp -o yaml + ``` +

+
+ + +31.
Delete the deployment you just created and watch all the pods are also being deleted +

+ + ``` + kubectl delete deploy webapp + + kubectl get po -l app=webapp -w + ``` +

+
+ + +32.
Create a deployment of webapp with image nginx:1.17.1 with container port 80 and verify the image version +

+ + ``` + kubectl create deploy webapp --image=nginx:1.17.1 --dry-run -o yaml > webapp.yaml + + // add the port section and create the deployment + + apiVersion: apps/v1 + kind: Deployment metadata: creationTimestamp: null + labels: + app: webapp + name: webapp spec: - containers: - - command: - - echo - - Hello I am from job - image: busybox - name: hello-job - resources: {} - restartPolicy: Never -status: {} - -kubectl create -f hello-job.yaml -``` -

-
- - -
Watch the job that runs 10 times one by one and verify 10 pods are created and delete those after it’s completed -

- -``` -kubectl get job -w -kubectl get po - -kubectl delete job hello-job -``` -

-
- - - -
Create the same job and make it run 10 times parallel -

- -``` -kubectl create job hello-job --image=busybox --dry-run -o yaml -- echo "Hello I am from job" > hello-job.yaml - -// edit the yaml file to add parallelism: 10 - -apiVersion: batch/v1 -kind: Job -metadata: - creationTimestamp: null - name: hello-job -spec: - parallelism: 10 - template: + replicas: 1 + selector: + matchLabels: + app: webapp + strategy: {} + template: + metadata: + creationTimestamp: null + labels: + app: webapp + spec: + containers: + - image: nginx:1.17.1 + name: nginx + ports: + - containerPort: 80 + resources: {} + status: {} + + kubectl create -f webapp.yaml + + // verify + kubectl describe deploy webapp | grep Image + ``` +

+
+ + +33.
Update the deployment with the image version 1.17.4 and verify +

+ + ``` + kubectl set image deploy/webapp nginx=nginx:1.17.4 + + kubectl describe deploy webapp | grep Image + ``` +

+
+ + +34.
Check the rollout history and make sure everything is ok after the update +

+ + ``` + kubectl rollout history deploy webapp + + kubectl get deploy webapp --show-labels + kubectl get rs -l app=webapp + kubectl get po -l app=webapp + ``` +

+
+ + +35.
Undo the deployment to the previous version 1.17.1 and verify Image has the previous version +

+ + ``` + kubectl rollout undo deploy webapp + + kubectl describe deploy webapp | grep Image + ``` +

+
+ + + +36.
Update the deployment with the image version 1.16.1 and verify the image and also check the rollout history +

+ + ``` + kubectl set image deploy/webapp nginx=nginx:1.16.1 + + kubectl describe deploy webapp | grep Image + + kubectl rollout history deploy webapp + ``` +

+
+ + + +37.
Update the deployment to the Image 1.17.1 and verify everything is ok +

+ + ``` + kubectl rollout undo deploy webapp --to-revision=3 + + kubectl describe deploy webapp | grep Image + + kubectl rollout status deploy webapp + ``` +

+
+ + +38.
Update the deployment with the wrong image version 1.100 and verify something is wrong with the deployment +

+ + ``` + kubectl set image deploy/webapp nginx=nginx:1.100 + + kubectl rollout status deploy webapp (still pending state) + + kubectl get pods (ImagePullErr) + ``` +

+
+ + +39.
Undo the deployment with the previous version and verify everything is Ok +

+ + ``` + kubectl rollout undo deploy webapp + kubectl rollout status deploy webapp + + kubectl get pods + ``` +

+
+ + +40.
Check the history of the specific revision of that deployment +

+ + ``` + kubectl rollout history deploy webapp --revision=7 + ``` +

+
+ + + +41.
Pause the rollout of the deployment +

+ + ``` + kubectl rollout pause deploy webapp + ``` +

+
+ + +42.
Update the deployment with the image version latest and check the history and verify nothing is going on +

+ + ``` + kubectl set image deploy/webapp nginx=nginx:latest + + kubectl rollout history deploy webapp (No new revision) + ``` +

+
+ + + +43.
Resume the rollout of the deployment +

+ + ``` + kubectl rollout resume deploy webapp + ``` +

+
+ + +44.
Check the rollout history and verify it has the new version + +

+ + ``` + kubectl rollout history deploy webapp + + kubectl rollout history deploy webapp --revision=9 + ``` +

+
+ + +45.
Apply the autoscaling to this deployment with minimum 10 and maximum 20 replicas and target CPU of 85% and verify hpa is created and replicas are increased to 10 from 1 + +

+ + ``` + kubectl autoscale deploy webapp --min=10 --max=20 --cpu-percent=85 + + kubectl get hpa + + kubectl get pod -l app=webapp + ``` +

+
+ + +46.
Clean the cluster by deleting deployment and hpa you just created +

+ + ``` + kubectl delete deploy webapp + + kubectl delete hpa webapp + ``` +

+
+ + +47.
Create a Job with an image node which prints node version and also verifies there is a pod created for this job +

+ + ``` + kubectl create job nodeversion --image=node -- node -v + + kubectl get job -w + kubectl get pod + ``` +

+
+ + + +48.
Get the logs of the job just created +

+ + ``` + kubectl logs // created from the job + ``` +

+
+ + + +49.
Output the yaml file for the Job with the image busybox which echos “Hello I am from job” +

+ + ``` + kubectl create job hello-job --image=busybox --dry-run -o yaml -- echo "Hello I am from job" + ``` +

+
+ + +50.
Copy the above YAML file to hello-job.yaml file and create the job +

+ + ``` + kubectl create job hello-job --image=busybox --dry-run -o yaml -- echo "Hello I am from job" > hello-job.yaml + + kubectl create -f hello-job.yaml + ``` +

+
+ + +51.
Verify the job and the associated pod is created and check the logs as well +

+ + ``` + kubectl get job + kubectl get po + + kubectl logs hello-job-* + ``` +

+
+ + + +52.
Delete the job we just created +

+ + ``` + kubectl delete job hello-job + ``` +

+
+ + +53.
Create the same job and make it run 10 times one after one +

+ + ``` + kubectl create job hello-job --image=busybox --dry-run -o yaml -- echo "Hello I am from job" > hello-job.yaml + + // edit the yaml file to add completions: 10 + + apiVersion: batch/v1 + kind: Job metadata: creationTimestamp: null + name: hello-job spec: - containers: - - command: - - echo - - Hello I am from job - image: busybox - name: hello-job - resources: {} - restartPolicy: Never -status: {} - -kubectl create -f hello-job.yaml -``` -

-
- - - -
Watch the job that runs 10 times parallelly and verify 10 pods are created and delete those after it’s completed -

- -``` -kubectl get job -w -kubectl get po - -kubectl delete job hello-job -``` -

-
- - - -
Create a Cronjob with busybox image that prints date and hello from kubernetes cluster message for every minute -

- -``` -kubectl create cronjob date-job --image=busybox --schedule="*/1 * * * *" -- bin/sh -c "date; echo Hello from kubernetes cluster" -``` -

-
- - - -
Output the YAML file of the above cronjob -

- -``` -kubectl get cj date-job -o yaml -``` -

-
- - - -
Verify that CronJob creating a separate job and pods for every minute to run and verify the logs of the pod -

- -``` -kubectl get job -kubectl get po - -kubectl logs date-job-- -``` -

-
- - - -
Delete the CronJob and verify all the associated jobs and pods are also deleted -

- -``` -kubectl delete cj date-job - -// verify pods and jobs -kubectl get po -kubectl get job -``` -

-
+ completions: 10 + template: + metadata: + creationTimestamp: null + spec: + containers: + - command: + - echo + - Hello I am from job + image: busybox + name: hello-job + resources: {} + restartPolicy: Never + status: {} + + kubectl create -f hello-job.yaml + ``` +

+
+ + +54.
Watch the job that runs 10 times one by one and verify 10 pods are created and delete those after it’s completed +

+ + ``` + kubectl get job -w + kubectl get po + + kubectl delete job hello-job + ``` +

+
+ + + +55.
Create the same job and make it run 10 times parallel +

+ + ``` + kubectl create job hello-job --image=busybox --dry-run -o yaml -- echo "Hello I am from job" > hello-job.yaml + + // edit the yaml file to add parallelism: 10 + + apiVersion: batch/v1 + kind: Job + metadata: + creationTimestamp: null + name: hello-job + spec: + parallelism: 10 + template: + metadata: + creationTimestamp: null + spec: + containers: + - command: + - echo + - Hello I am from job + image: busybox + name: hello-job + resources: {} + restartPolicy: Never + status: {} + + kubectl create -f hello-job.yaml + ``` +

+
+ + + +56.
Watch the job that runs 10 times parallelly and verify 10 pods are created and delete those after it’s completed +

+ + ``` + kubectl get job -w + kubectl get po + + kubectl delete job hello-job + ``` +

+
+ + + +57.
Create a Cronjob with busybox image that prints date and hello from kubernetes cluster message for every minute +

+ + ``` + kubectl create cronjob date-job --image=busybox --schedule="*/1 * * * *" -- bin/sh -c "date; echo Hello from kubernetes cluster" + ``` +

+
+ + + +58.
Output the YAML file of the above cronjob +

+ + ``` + kubectl get cj date-job -o yaml + ``` +

+
+ + + +59.
Verify that CronJob creating a separate job and pods for every minute to run and verify the logs of the pod +

+ + ``` + kubectl get job + kubectl get po + + kubectl logs date-job-- + ``` +

+
+ + + +60.
Delete the CronJob and verify all the associated jobs and pods are also deleted +

+ + ``` + kubectl delete cj date-job + + // verify pods and jobs + kubectl get po + kubectl get job + ``` +

+
diff --git a/services-and-networking.md b/services-and-networking.md index 8c15d0e..84e66c7 100644 --- a/services-and-networking.md +++ b/services-and-networking.md @@ -8,131 +8,131 @@ ## Questions -
Create an nginx pod with a yaml file with label my-nginx and expose the port 80 -

- -``` -kubectl run nginx --image=nginx --restart=Never --port=80 --dry-run -o yaml > nginx.yaml - -// edit the label app: my-nginx and create the pod -apiVersion: v1 -kind: Pod -metadata: - creationTimestamp: null - labels: - app: my-nginx - name: nginx -spec: - containers: - - image: nginx - name: nginx - ports: - - containerPort: 80 - resources: {} - dnsPolicy: ClusterFirst - restartPolicy: Never -status: {} - -kubectl create -f nginx.yaml -``` -

-
- - -
Create the service for this nginx pod with the pod selector app: my-nginx -

- -``` -// create the below service -apiVersion: v1 -kind: Service -metadata: - name: my-service -spec: - selector: - app: my-nginx - ports: - - protocol: TCP - port: 80 - targetPort: 9376 - -kubectl create -f nginx-svc.yaml -``` -

-
- - -
Find out the label of the pod and verify the service has the same label -

- -``` -// get the pod with labels -kubectl get po nginx --show-labels - -// get the service and chekc the selector column -kubectl get svc my-service -o wide -``` -

-
- - -
Delete the service and create the service with kubectl expose command and verify the label -

- -``` -// delete the service -kubectl delete svc my-service - -// create the service again -kubectl expose po nginx --port=80 --target-port=9376 - -// verify the label -kubectl get svc -l app=my-nginx -``` -

-
- - -
Delete the service and create the service again with type NodePort -

- -``` -// delete the service -kubectl delete svc nginx - -// create service with expose command -kubectl expose po nginx --port=80 --type=NodePort -``` -

-
- - -
Create the temporary busybox pod and hit the service. Verify the service that it should return the nginx page index.html -

- -``` -// get the clusterIP from this command -kubectl get svc nginx -o wide - -// create temporary busybox to check the nodeport -kubectl run busybox --image=busybox --restart=Never -it --rm -- wget -o- :80 -``` -

-
- - -
Create a NetworkPolicy which denies all ingress traffic -

- -``` -apiVersion: networking.k8s.io/v1 -kind: NetworkPolicy -metadata: - name: default-deny -spec: - podSelector: {} - policyTypes: - - Ingress -``` -

-
+1.
Create an nginx pod with a yaml file with label my-nginx and expose the port 80 +

+ + ``` + kubectl run nginx --image=nginx --restart=Never --port=80 --dry-run -o yaml > nginx.yaml + + // edit the label app: my-nginx and create the pod + apiVersion: v1 + kind: Pod + metadata: + creationTimestamp: null + labels: + app: my-nginx + name: nginx + spec: + containers: + - image: nginx + name: nginx + ports: + - containerPort: 80 + resources: {} + dnsPolicy: ClusterFirst + restartPolicy: Never + status: {} + + kubectl create -f nginx.yaml + ``` +

+
+ + +2.
Create the service for this nginx pod with the pod selector app: my-nginx +

+ + ``` + // create the below service + apiVersion: v1 + kind: Service + metadata: + name: my-service + spec: + selector: + app: my-nginx + ports: + - protocol: TCP + port: 80 + targetPort: 9376 + + kubectl create -f nginx-svc.yaml + ``` +

+
+ + +3.
Find out the label of the pod and verify the service has the same label +

+ + ``` + // get the pod with labels + kubectl get po nginx --show-labels + + // get the service and chekc the selector column + kubectl get svc my-service -o wide + ``` +

+
+ + +4.
Delete the service and create the service with kubectl expose command and verify the label +

+ + ``` + // delete the service + kubectl delete svc my-service + + // create the service again + kubectl expose po nginx --port=80 --target-port=9376 + + // verify the label + kubectl get svc -l app=my-nginx + ``` +

+
+ + +5.
Delete the service and create the service again with type NodePort +

+ + ``` + // delete the service + kubectl delete svc nginx + + // create service with expose command + kubectl expose po nginx --port=80 --type=NodePort + ``` +

+
+ + +6.
Create the temporary busybox pod and hit the service. Verify the service that it should return the nginx page index.html +

+ + ``` + // get the clusterIP from this command + kubectl get svc nginx -o wide + + // create temporary busybox to check the nodeport + kubectl run busybox --image=busybox --restart=Never -it --rm -- wget -o- :80 + ``` +

+
+ + +7.
Create a NetworkPolicy which denies all ingress traffic +

+ + ``` + apiVersion: networking.k8s.io/v1 + kind: NetworkPolicy + metadata: + name: default-deny + spec: + podSelector: {} + policyTypes: + - Ingress + ``` +

+
diff --git a/state-persistence.md b/state-persistence.md index 74218df..cbd6fb1 100644 --- a/state-persistence.md +++ b/state-persistence.md @@ -8,182 +8,182 @@ ## Questions -
List Persistent Volumes in the cluster -

- -``` -kubectl get pv -``` -

-
- - -
Create a hostPath PersistentVolume named task-pv-volume with storage 10Gi, access modes ReadWriteOnce, storageClassName manual, and volume at /mnt/data and verify -

- -``` -// task-pv-volume.yaml - -apiVersion: v1 -kind: PersistentVolume -metadata: - name: task-pv-volume - labels: - type: local -spec: - storageClassName: manual - capacity: - storage: 10Gi - accessModes: - - ReadWriteOnce - hostPath: - path: "/mnt/data" - -kubectl create -f task-pv-volume.yaml - -kubectl get pv -``` -

-
- - - -
Create a PersistentVolumeClaim of at least 3Gi storage and access mode ReadWriteOnce and verify status is Bound -

- -``` -// task-pv-claim.yaml - -apiVersion: v1 -kind: PersistentVolumeClaim -metadata: - name: task-pv-claim -spec: - storageClassName: manual - accessModes: - - ReadWriteOnce - resources: - requests: - storage: 3Gi - -kubectl create -f task-pv-claim.yaml - -kubectl get pvc -``` -

-
- - -
Delete persistent volume and PersistentVolumeClaim we just created -

- -``` -kubectl delete pvc task-pv-claim -kubectl delete pv task-pv-volume -``` -

-
- - -
Create a Pod with an image Redis and configure a volume that lasts for the lifetime of the Pod -

- -``` -// emptyDir is the volume that lasts for the life of the pod - -apiVersion: v1 -kind: Pod -metadata: - name: redis -spec: - containers: - - name: redis - image: redis - volumeMounts: - - name: redis-storage - mountPath: /data/redis - volumes: - - name: redis-storage - emptyDir: {} - -kubectl create -f redis-storage.yaml -``` -

-
- - -
Exec into the above pod and create a file named file.txt with the text ‘This is called the file’ in the path /data/redis and open another tab and exec again with the same pod and verifies file exist in the same path. -

- -``` -// first terminal -kubectl exec -it redis-storage /bin/sh -cd /data/redis -echo 'This is called the file' > file.txt - -//open another tab -kubectl exec -it redis-storage /bin/sh -cat /data/redis/file.txt -``` -

-
- - -
Delete the above pod and create again from the same yaml file and verifies there is no file.txt in the path /data/redis. -

- -``` -kubectl delete pod redis - -kubectl create -f redis-storage.yaml -kubectl exec -it redis-storage /bin/sh -cat /data/redis/file.txt // file doesn't exist -``` -

-
- - -
Create PersistentVolume named task-pv-volume with storage 10Gi, access modes ReadWriteOnce, storageClassName manual, and volume at /mnt/data and Create a PersistentVolumeClaim of at least 3Gi storage and access mode ReadWriteOnce and verify status is Bound -

- -``` -kubectl create -f task-pv-volume.yaml -kubectl create -f task-pv-claim.yaml - -kubectl get pv -kubectl get pvc -``` -

-
- - -
Create an nginx pod with containerPort 80 and with a PersistentVolumeClaim task-pv-claim and has a mouth path "/usr/share/nginx/html" -

- -``` -// task-pv-pod.yaml - -apiVersion: v1 -kind: Pod -metadata: - name: task-pv-pod -spec: - volumes: - - name: task-pv-storage - persistentVolumeClaim: - claimName: task-pv-claim - containers: - - name: task-pv-container - image: nginx - ports: - - containerPort: 80 - name: "http-server" - volumeMounts: - - mountPath: "/usr/share/nginx/html" - name: task-pv-storage +1.

List Persistent Volumes in the cluster +

+ + ``` + kubectl get pv + ``` +

+
+ + +2.
Create a hostPath PersistentVolume named task-pv-volume with storage 10Gi, access modes ReadWriteOnce, storageClassName manual, and volume at /mnt/data and verify +

+ + ``` + // task-pv-volume.yaml + + apiVersion: v1 + kind: PersistentVolume + metadata: + name: task-pv-volume + labels: + type: local + spec: + storageClassName: manual + capacity: + storage: 10Gi + accessModes: + - ReadWriteOnce + hostPath: + path: "/mnt/data" + + kubectl create -f task-pv-volume.yaml + + kubectl get pv + ``` +

+
+ + + +3.
Create a PersistentVolumeClaim of at least 3Gi storage and access mode ReadWriteOnce and verify status is Bound +

+ + ``` + // task-pv-claim.yaml + + apiVersion: v1 + kind: PersistentVolumeClaim + metadata: + name: task-pv-claim + spec: + storageClassName: manual + accessModes: + - ReadWriteOnce + resources: + requests: + storage: 3Gi -kubectl create -f task-pv-pod.yaml -``` -

-
- + kubectl create -f task-pv-claim.yaml + + kubectl get pvc + ``` +

+
+ + +4.
Delete persistent volume and PersistentVolumeClaim we just created +

+ + ``` + kubectl delete pvc task-pv-claim + kubectl delete pv task-pv-volume + ``` +

+
+ + +5.
Create a Pod with an image Redis and configure a volume that lasts for the lifetime of the Pod +

+ + ``` + // emptyDir is the volume that lasts for the life of the pod + + apiVersion: v1 + kind: Pod + metadata: + name: redis + spec: + containers: + - name: redis + image: redis + volumeMounts: + - name: redis-storage + mountPath: /data/redis + volumes: + - name: redis-storage + emptyDir: {} + + kubectl create -f redis-storage.yaml + ``` +

+
+ + +6.
Exec into the above pod and create a file named file.txt with the text ‘This is called the file’ in the path /data/redis and open another tab and exec again with the same pod and verifies file exist in the same path. +

+ + ``` + // first terminal + kubectl exec -it redis-storage /bin/sh + cd /data/redis + echo 'This is called the file' > file.txt + + //open another tab + kubectl exec -it redis-storage /bin/sh + cat /data/redis/file.txt + ``` +

+
+ + +7.
Delete the above pod and create again from the same yaml file and verifies there is no file.txt in the path /data/redis. +

+ + ``` + kubectl delete pod redis + + kubectl create -f redis-storage.yaml + kubectl exec -it redis-storage /bin/sh + cat /data/redis/file.txt // file doesn't exist + ``` +

+
+ + +8.
Create PersistentVolume named task-pv-volume with storage 10Gi, access modes ReadWriteOnce, storageClassName manual, and volume at /mnt/data and Create a PersistentVolumeClaim of at least 3Gi storage and access mode ReadWriteOnce and verify status is Bound +

+ + ``` + kubectl create -f task-pv-volume.yaml + kubectl create -f task-pv-claim.yaml + + kubectl get pv + kubectl get pvc + ``` +

+
+ + +9.
Create an nginx pod with containerPort 80 and with a PersistentVolumeClaim task-pv-claim and has a mouth path "/usr/share/nginx/html" +

+ + ``` + // task-pv-pod.yaml + + apiVersion: v1 + kind: Pod + metadata: + name: task-pv-pod + spec: + volumes: + - name: task-pv-storage + persistentVolumeClaim: + claimName: task-pv-claim + containers: + - name: task-pv-container + image: nginx + ports: + - containerPort: 80 + name: "http-server" + volumeMounts: + - mountPath: "/usr/share/nginx/html" + name: task-pv-storage + + kubectl create -f task-pv-pod.yaml + ``` +

+
+