1. Describe the pod to identify the issue: kubectl describe pod <pod -name> 2. Check the image pull errors and verify image availability: kubectl get events docker pull <image -name> 3. Update the Deployment with a correct or accessible image: kubectl edit deployment <deployment -name> 4. Verify pod status: kubectl get pods Explanation: Image -related issues often arise from incorrect paths or access restrictions. Resolving these ensures successful container creation. Set up a ClusterRole and ClusterRoleBinding to allow a user named admin -user to view all resources across all namespaces. Provide YAML definitions and validation steps. ee the Solution below. Solution: 1. Create a ClusterRole YAML file: apiVersion: rbac.authorization.k8s.io/v1 kind: ClusterRole metadata: name: view-all rules: - apiGroups: [""] resources: ["*"] verbs: ["get", "list", "watch"] 2. Create a ClusterRoleBinding YAML file: apiVersion: rbac.authorization.k8s.io/v1 kind: ClusterRoleBinding metadata: name: view -all-binding
subjects: - kind: User name: admin -user roleRef: kind: ClusterRole name: view -all apiGroup: rbac.authorization.k8s.io 3. Apply both files and verify permissions: kubectl auth can -i list pods --as admin -user --all-namespaces Explanation: Cluster -wide permissions grant users the ability to manage resources across namespaces, aiding in administrative tasks. Use OpenShift CLI to enable and configure monitoring alerts for persistent volume usage exceeding 80%. Provide steps to test the alert functionality. ee the Solution below. Solution: 1. Edit the Prometheus configuration: kubectl edit configmap prometheus -config -n openshift -monitoring Add an alert rule: groups: - name: volume.rules rules: - alert: HighVolumeUsage expr: kubelet_volume_stats_used_bytes / kubelet_volume_stats_capacity_bytes > 0.8 for: 2m labels: severity: warning annotations: summary: "Persistent Volume usage is high" description: "Volume usage is above 80% for {{ $labels.persistentvolumeclaim }}" 2. Restart Prometheus and simulate high usage: kubectl rollout restart deployment prometheus -n openshift -monitoring kubectl exec -it <pod -name> -- dd if=/dev/zero of=/mount/path bs=1M count=900
Explanation: Persistent volume monitoring detects capacity issues, triggering alerts to prevent service disruption due to full volumes. Migrate an application from one namespace to another without downtime. Include commands to copy configurations, secrets, and deployments. ee the Solution below. Solution: 1. Export resources from the source namespace: kubectl get all,cm,secrets -n source -namespace -o yaml > backup.yaml 2. Modify the namespace in the backup file: sed -i 's/source -namespace/target -namespace/g' backup.yaml 3. Apply the modified file in the target namespace: kubectl apply -f backup.yaml 4. Verify resources in the new namespace: kubectl get all -n target -namespace Explanation: Namespace migrations require careful handling of resources to maintain functionality and avoid service interruptions. Configure OpenShift autoscaling policies to handle a sudden traffic spike on an application. Simulate the spike and validate the scaling. ee the Solution below. Solution: 1. Create an HPA for the application: kubectl autoscale deployment app -deployment --cpu-percent=50 --min=2 --max=10
2. Simulate high CPU usage: kubectl run stress --image=alpine -- sh -c "apk add stress && stress --cpu 1" 3. Verify scaling behavior: kubectl get hpa kubectl get pods Explanation: Autoscaling ensures that applications adapt dynamically to workload demands, improving resource utilization and maintaining performance. Configure a StatefulSet to deploy a MySQL database with persistent storage. Include steps to define the StatefulSet, create a PersistentVolume (PV) and PersistentVolumeClaim (PVC), and verify the database is running correctly. ee the Solution below. Solution: 1. Create a PV YAML file mysql -pv.yaml: apiVersion: v1 kind: PersistentVolume metadata: name: mysql -pv spec: capacity: storage: 5Gi accessModes: - ReadWriteOnce hostPath: path: /data/mysql 2. Create a PVC YAML file mysql -pvc.yaml: apiVersion: v1 kind: PersistentVolumeClaim metadata: name: mysql -pvc spec: accessModes: - ReadWriteOnce resources: requests: storage: 5Gi 3. Create a StatefulSet YAML file mysql -statefulset.yaml: apiVersion: apps/v1 kind: StatefulSet metadata: name: mysql spec: serviceName: "mysql" replicas: 1 selector: matchLabels: app: mysql template: metadata: labels: app: mysql spec: containers: - name: mysql image: mysql:5.7 ports: - containerPort: 3306 env: - name: MYSQL_ROOT_PASSWORD value: rootpassword volumeMounts: - name: mysql -data mountPath: /var/lib/mysql volumeClaimTemplates: - metadata: name: mysql -data spec: accessModes: ["ReadWriteOnce"] resources: requests: storage: 5Gi 4. Apply all YAML files: kubectl apply -f mysql -pv.yaml kubectl apply -f mysql -pvc.yaml kubectl apply -f mysql -statefulset.yaml 5. Verify the StatefulSet and pod: kubectl get statefulsets
kubectl get pods Explanation: StatefulSets ensure stable identities for applications requiring persistent data, like databases. Coupling them with PVs and PVCs ensures data persistence across restarts. Use OpenShift CLI to configure and test a Service Account with limited permissions. Create a Role for accessing ConfigMaps, bind it to the Service Account, and validate the access. ee the Solution below. Solution: 1. Create a Service Account: kubectl create serviceaccount limited -access 2. Create a Role YAML file configmap -role.yaml: apiVersion: rbac.authorization.k8s.io/v1 kind: Role metadata: namespace: default name: configmap -reader rules: - apiGroups: [""] resources: ["configmaps"] verbs: ["get", "list"] 3. Create a RoleBinding YAML file rolebinding.yaml: apiVersion: rbac.authorization.k8s.io/v1 kind: RoleBinding metadata: name: configmap -binding namespace: default subjects: - kind: ServiceAccount name: limited -access roleRef: kind: Role name: configmap -reader apiGroup: rbac.authorization.k8s.io 4. Apply the YAML files:
kubectl get pods 4. Test the application by exposing the Deployment: kubectl expose deployment nginx -deployment --type=NodePort --port=80 kubectl get svc 5. Use the NodePort and cluster IP to confirm that the application is serving requests. Explanation: Deployments provide a scalable and declarative way to manage applications. YAML manifests ensure the configuration is consistent, while NodePort services expose the application for testing. Verifying replicas ensures that the application is running as expected and resilient. Your team requires an application to load specific configuration data dynamically during runtime. Create a ConfigMap to hold key -value pairs for application settings, and update an existing Deployment to use this ConfigMap. Provide a complete YAML definition for both the ConfigMap and the updated Deployment, and demonstrate how to validate that the configuration is applied correctly. ee the Solution below. Solution: 1. Create a ConfigMap YAML file named app-config.yaml: apiVersion: v1 kind: ConfigMap metadata: name: app-config data: APP_ENV: production APP_DEBUG: "false" 2. Apply the ConfigMap using: kubectl apply -f app -config.yaml 3. Update the Deployment YAML to reference the ConfigMap: apiVersion: apps/v1 kind: Deployment metadata: name: app-deployment spec: replicas: 1
