Kubernetes Architecture Overview

🎯 TL;DR

Kubernetes is an open-source container orchestration system that automates the deployment, scaling, and management of containerized applications. It matters because it simplifies the process of managing complex distributed systems, allowing developers to focus on writing code rather than managing infrastructure. The single most critical insight is that Kubernetes provides a layer of abstraction between the application and the underlying infrastructure, making it easier to deploy and manage applications in a variety of environments.
Kubernetes is like a highly efficient, automated factory that helps manage and run many applications at the same time.

🌱 Beginner Zone

What is Kubernetes in Plain English?

Kubernetes is like a conductor in an orchestra, helping all the different parts work together in harmony. Imagine you have many different applications, each with its own specific needs and requirements, and you need to manage and run them all at the same time. Kubernetes is the tool that helps you do that, by automating the deployment, scaling, and management of these applications, so you can focus on writing code rather than managing infrastructure.

Why Should You Learn This?

Learning Kubernetes is essential because it allows you to efficiently manage and deploy complex distributed systems, which is a critical skill in today's cloud-native world. Without knowing Kubernetes, you would have to manually manage each application, which can be time-consuming and prone to errors. By learning Kubernetes, you can improve your career prospects and stay competitive in the job market.

Prerequisites — What to Know First

• Containers (e.g., Docker)
• Container runtimes (e.g., Docker Engine)
• Networking fundamentals (e.g., IP addresses, ports)
• Basic Linux commands
• Familiarity with cloud platforms (e.g., AWS, GCP, Azure)

Quick Start — Get It Working in 5 Minutes

# Create a Kubernetes deployment YAML file
apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-world
spec:
  replicas: 1
  selector:
    matchLabels:
      app: hello-world
  template:
    metadata:
      labels:
        app: hello-world
    spec:
      containers:
      - name: hello-world
        image: gcr.io/google-samples/hello-app:1.0
        ports:
        - containerPort: 8080

# Apply the YAML file to create the deployment
kubectl apply -f deployment.yaml
# Verify the deployment is running
kubectl get deployments

Your First Mistake

The #1 mistake beginners make in their first week using Kubernetes is not understanding the difference between a Pod and a Deployment. A Pod is a single instance of a running application, while a Deployment is a way to manage and scale multiple Pods. Without understanding this distinction, you may end up trying to manage individual Pods instead of using a Deployment, which can lead to confusion and errors.

📘 What is Kubernetes? (Core Definition)

Kubernetes is an open-source container orchestration system that automates the deployment, scaling, and management of containerized applications. It was first introduced in 2014 by Google and has since become a widely adopted standard for managing containerized applications in production environments. Kubernetes provides a layer of abstraction between the application and the underlying infrastructure, making it easier to deploy and manage applications in a variety of environments.

⚙️ How It Works Internally [Medium → Expert]

Kubernetes uses a complex system of internal data structures, algorithms, and threading models to manage containerized applications. Here is a high-level overview of how it works:

1. API Server: The API server is the entry point for all Kubernetes operations. It receives requests from users and other components, and validates and processes them.
2. Controller Manager: The controller manager is responsible for running and managing the various controllers that make up the Kubernetes control plane.
3. Scheduler: The scheduler is responsible for assigning Pods to nodes in the cluster.
4. Worker Node: The worker node is where the actual work of running containers happens.
   Here is an ASCII architecture diagram:

                      +---------------+
                      |  API Server  |
                      +---------------+
                             |
                             |
                             v
                      +---------------+
                      | Controller  |
                      |  Manager    |
                      +---------------+
                             |
                             |
                             v
                      +---------------+
                      |  Scheduler  |
                      +---------------+
                             |
                             |
                             v
                      +---------------+
                      |  Worker Node  |
                      +---------------+

The version evolution of Kubernetes has introduced significant changes in behavior across major versions. For example, Kubernetes 1.14 introduced the concept of "RuntimeClasses", which allows for more fine-grained control over the container runtime.

🔑 Core Concepts (minimum 8 concepts)

• Pod [🌱 Beginner]: A Pod is the basic execution unit in Kubernetes. It represents a single instance of a running application. Edge case: A Pod can contain multiple containers, but they must all share the same network namespace. WHY it matters: Pods provide a way to manage and scale applications, making it easier to deploy and manage complex distributed systems.
• Deployment [⚙️ Medium]: A Deployment is a way to manage and scale multiple Pods. It provides a way to describe the desired state of an application, and Kubernetes will automatically manage the rollout of new versions. Edge case: Deployments can be used to manage stateful applications, but require additional configuration. WHY it matters: Deployments provide a way to manage the lifecycle of applications, making it easier to deploy and manage complex distributed systems.
• Service [🌱 Beginner]: A Service is a way to expose an application to the outside world. It provides a stable network identity and load balancing for accessing the application. Edge case: Services can be used to expose multiple applications, but require additional configuration. WHY it matters: Services provide a way to access applications, making it easier to deploy and manage complex distributed systems.
• Persistent Volume [⚙️ Medium]: A Persistent Volume is a way to provide persistent storage for applications. It provides a way to store data that persists even if the application is restarted or deleted. Edge case: Persistent Volumes can be used with stateful applications, but require additional configuration. WHY it matters: Persistent Volumes provide a way to store data, making it easier to deploy and manage complex distributed systems.
• ConfigMap [⚙️ Medium]: A ConfigMap is a way to store and manage configuration data for applications. It provides a way to decouple configuration data from the application code. Edge case: ConfigMaps can be used with multiple applications, but require additional configuration. WHY it matters: ConfigMaps provide a way to manage configuration data, making it easier to deploy and manage complex distributed systems.
• Secret [🚀 Expert]: A Secret is a way to store and manage sensitive data for applications. It provides a way to store data such as passwords and API keys. Edge case: Secrets can be used with multiple applications, but require additional configuration. WHY it matters: Secrets provide a way to store sensitive data, making it easier to deploy and manage complex distributed systems.
• Ingress [⚙️ Medium]: An Ingress is a way to expose an application to the outside world. It provides a way to manage incoming HTTP requests and route them to the correct application. Edge case: Ingress can be used with multiple applications, but require additional configuration. WHY it matters: Ingress provides a way to access applications, making it easier to deploy and manage complex distributed systems.
• Network Policy [🚀 Expert]: A Network Policy is a way to control traffic flow between applications. It provides a way to define rules for allowing or denying traffic between Pods. Edge case: Network Policies can be used with multiple applications, but require additional configuration. WHY it matters: Network Policies provide a way to control traffic flow, making it easier to deploy and manage complex distributed systems.

💻 Code Examples

[🌱 Beginner] — Simple Working Example

# Create a Kubernetes deployment YAML file
apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-world
spec:
  replicas: 1
  selector:
    matchLabels:
      app: hello-world
  template:
    metadata:
      labels:
        app: hello-world
    spec:
      containers:
      - name: hello-world
        image: gcr.io/google-samples/hello-app:1.0
        ports:
        - containerPort: 8080

# Apply the YAML file to create the deployment
kubectl apply -f deployment.yaml
# Verify the deployment is running
kubectl get deployments

[⚙️ Medium] — Real-World Usage

# Create a Kubernetes deployment YAML file
apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-world
spec:
  replicas: 3
  selector:
    matchLabels:
      app: hello-world
  template:
    metadata:
      labels:
        app: hello-world
    spec:
      containers:
      - name: hello-world
        image: gcr.io/google-samples/hello-app:1.0
        ports:
        - containerPort: 8080
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0

# Apply the YAML file to create the deployment
kubectl apply -f deployment.yaml
# Verify the deployment is running
kubectl get deployments

[🚀 Expert] — Production-Grade Example

# Create a Kubernetes deployment YAML file
apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-world
spec:
  replicas: 3
  selector:
    matchLabels:
      app: hello-world
  template:
    metadata:
      labels:
        app: hello-world
    spec:
      containers:
      - name: hello-world
        image: gcr.io/google-samples/hello-app:1.0
        ports:
        - containerPort: 8080
        livenessProbe:
          httpGet:
            path: /healthz
            port: 8080
          initialDelaySeconds: 10
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /healthz
            port: 8080
          initialDelaySeconds: 10
          periodSeconds: 10
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0

# Apply the YAML file to create the deployment
kubectl apply -f deployment.yaml
# Verify the deployment is running
kubectl get deployments

Anti-Pattern Table (minimum 5 rows)

🚨 Mistakes by Level

[🌱 Beginner Mistakes] — Week 1 pitfalls

• Not understanding the difference between a Pod and a Deployment
• Not using a liveness probe
• Not using a readiness probe
• Not using a rolling update strategy
• Not using resource limits

[⚙️ Medium Mistakes] — First 6 months in production

• Not using a ConfigMap
• Not using a Secret
• Not using a Network Policy
• Not monitoring application performance
• Not using a logging mechanism

[🚀 Expert Mistakes] — Architecture-level decisions that cost months to fix

• Not using a service mesh
• Not using a container registry
• Not using a continuous integration/continuous deployment (CI/CD) pipeline
• Not using a monitoring and logging solution
• Not using a security solution

🔍 Code Review Red Flags

• Flag: Not using a liveness probe | Why wrong: Application will not be restarted if it becomes unresponsive | Fix: Use a liveness probe to detect when an application is unresponsive and restart it.
• Flag: Not using a readiness probe | Why wrong: Application will not be considered ready to receive traffic | Fix: Use a readiness probe to detect when an application is ready to receive traffic.
• Flag: Not using a rolling update strategy | Why wrong: Application will experience downtime during updates | Fix: Use a rolling update strategy to minimize downtime during updates.
• Flag: Not using resource limits | Why wrong: Application may consume all available resources, causing other applications to fail | Fix: Use resource limits to prevent an application from consuming all available resources.
• Flag: Not using a ConfigMap | Why wrong: Application configuration will be hardcoded, making it difficult to manage | Fix: Use a ConfigMap to store application configuration and make it easier to manage.

🆚 Comparison with Alternatives

Use Kubernetes when you need to manage large-scale, complex applications. Use Docker Swarm when you need to manage small-scale, simple applications. Use Apache Mesos when you need to manage large-scale, complex applications and require a high degree of customization. Use OpenShift when you need to manage large-scale, complex applications and require a high degree of security and compliance. Use Rancher when you need to manage large-scale, complex applications and require a high degree of flexibility and customization.

🏗️ Real-World Scenarios (minimum 5)

• Situation: A company has a large-scale e-commerce application that needs to be deployed and managed in a cloud environment. Root Cause: The application is complex and requires a high degree of scalability, availability, and security. Solution: Use Kubernetes to deploy and manage the application. Outcome: The application is deployed and managed successfully, with high scalability, availability, and security. Lesson: Kubernetes is a good choice for large-scale, complex applications.
• Situation: A company has a small-scale web application that needs to be deployed and managed in a cloud environment. Root Cause: The application is simple and requires a low degree of scalability, availability, and security. Solution: Use Docker Swarm to deploy and manage the application. Outcome: The application is deployed and managed successfully, with low scalability, availability, and security. Lesson: Docker Swarm is a good choice for small-scale, simple applications.
• Situation: A company has a large-scale, complex application that needs to be deployed and managed in a cloud environment. Root Cause: The application requires a high degree of customization and flexibility. Solution: Use Apache Mesos to deploy and manage the application. Outcome: The application is deployed and managed successfully, with high scalability, availability, and security. Lesson: Apache Mesos is a good choice for large-scale, complex applications that require a high degree of customization and flexibility.
• Situation: A company has a large-scale, complex application that needs to be deployed and managed in a cloud environment. Root Cause: The application requires a high degree of security and compliance. Solution: Use OpenShift to deploy and manage the application. Outcome: The application is deployed and managed successfully, with high scalability, availability, and security. Lesson: OpenShift is a good choice for large-scale, complex applications that require a high degree of security and compliance.
• Situation: A company has a large-scale, complex application that needs to be deployed and managed in a cloud environment. Root Cause: The application requires a high degree of flexibility and customization. Solution: Use Rancher to deploy and manage the application. Outcome: The application is deployed and managed successfully, with high scalability, availability, and security. Lesson: Rancher is a good choice for large-scale, complex applications that require a high degree of flexibility and customization.

⚡ Performance & Optimization [🚀 Expert]

Kubernetes provides a number of features to optimize performance, including:

• Horizontal Pod Autoscaling (HPA): Automatically scales the number of Pods based on resource utilization.
• Vertical Pod Autoscaling (VPA): Automatically adjusts the resources allocated to a Pod based on resource utilization.
• Cluster Autoscaling (CA): Automatically scales the number of nodes in a cluster based on resource utilization.
• Resource Limits: Limits the amount of resources a Pod can consume.
• Resource Requests: Requests a specific amount of resources for a Pod.
  To optimize performance, it is recommended to:
• Use HPA and VPA to automatically scale Pods and adjust resources.
• Use CA to automatically scale the number of nodes in a cluster.
• Set resource limits and requests to prevent over-utilization of resources.
• Monitor application performance and adjust configuration as needed.

🔒 Security Considerations

Kubernetes provides a number of features to secure applications, including:

• Network Policies: Control traffic flow between Pods and services.
• Secrets: Store sensitive data, such as passwords and API keys.
• ConfigMaps: Store configuration data, such as application settings.
• Role-Based Access Control (RBAC): Control access to resources based on user roles.
• Pod Security Policies: Control the security settings of Pods.
  To secure applications, it is recommended to:
• Use Network Policies to control traffic flow.
• Use Secrets to store sensitive data.
• Use ConfigMaps to store configuration data.
• Use RBAC to control access to resources.
• Use Pod Security Policies to control the security settings of Pods.

👁️ Observability [🚀 Expert]

Kubernetes provides a number of features to monitor and observe applications, including:

• Metrics: Collect metrics on application performance and resource utilization.
• Logs: Collect logs on application activity and errors.
• Traces: Collect traces on application requests and responses.
• Prometheus: A monitoring system and time series database.
• Grafana: A visualization tool for metrics and logs.
  To monitor and observe applications, it is recommended to:
• Use Metrics to collect metrics on application performance and resource utilization.
• Use Logs to collect logs on application activity and errors.
• Use Traces to collect traces on application requests and responses.
• Use Prometheus to collect and store metrics.
• Use Grafana to visualize metrics and logs.

✅ Production Readiness Checklist

1. Security: Use Network Policies, Secrets, ConfigMaps, RBAC, and Pod Security Policies to secure applications.
2. Monitoring: Use Metrics, Logs, Traces, Prometheus, and Grafana to monitor and observe applications.
3. Logging: Use Logs to collect logs on application activity and errors.
4. HA: Use High Availability to ensure applications are always available.
5. DR: Use Disaster Recovery to ensure applications can recover from failures.
6. Capacity: Use Capacity Planning to ensure applications have sufficient resources.
7. Perf Testing: Use Performance Testing to ensure applications perform well under load.
8. Deployment: Use Deployment Strategies to ensure applications are deployed correctly.
9. Rollback: Use Rollback Strategies to ensure applications can be rolled back in case of errors.
10. Config Management: Use Config Management to manage application configuration.
11. Secret Management: Use Secret Management to manage sensitive data.
12. Network Management: Use Network Management to manage network traffic.
13. Storage Management: Use Storage Management to manage storage resources.
14. Backup: Use Backup to ensure applications can be restored in case of failures.
15. Restore: Use Restore to ensure applications can be restored from backups.
16. Upgrade: Use Upgrade to ensure applications are up-to-date with the latest features and security patches.
17. Downgrade: Use Downgrade to ensure applications can be downgraded in case of errors.
18. Testing: Use Testing to ensure applications are thoroughly tested before deployment.
19. Validation: Use Validation to ensure applications are valid and functional.
20. Documentation: Use Documentation to ensure applications are well-documented and easy to use.

🎯 Interview Q&A — EXACTLY 23 QUESTIONS

5 [🌱 Beginner] — Conceptual, no experience needed

Q1 [🌱 Beginner] What is Kubernetes?

A: Kubernetes is an open-source container orchestration system.
Q2 [🌱 Beginner] What is a Pod?
A: A Pod is the basic execution unit in Kubernetes.
Q3 [🌱 Beginner] What is a Deployment?
A: A Deployment is a way to manage and scale multiple Pods.
Q4 [🌱 Beginner] What is a Service?
A: A Service is a way to expose an application to the outside world.
Q5 [🌱 Beginner] What is a Persistent Volume?
A: A Persistent Volume is a way to provide persistent storage for applications.

5 [⚙️ Medium] — Practical, scenario-based

Q6 [⚙️ Medium] How do you deploy an application to Kubernetes?

A: You can deploy an application to Kubernetes using a YAML file and the kubectl apply command.
Q7 [⚙️ Medium] How do you scale an application in Kubernetes?
A: You can scale an application in Kubernetes using the kubectl scale command.
Q8 [⚙️ Medium] How do you monitor an application in Kubernetes?
A: You can monitor an application in Kubernetes using Metrics, Logs, and Traces.
Q9 [⚙️ Medium] How do you secure an application in Kubernetes?
A: You can secure an application in Kubernetes using Network Policies, Secrets, and ConfigMaps.
Q10 [⚙️ Medium] How do you backup an application in Kubernetes?
A: You can backup an application in Kubernetes using a Backup tool, such as Velero.

5 [🚀 Expert] — Deep internals + debugging

Q11 [🚀 Expert] What is the difference between a Pod and a Deployment?

A: A Pod is a single instance of a running application, while a Deployment is a way to manage and scale multiple Pods.
Q12 [🚀 Expert] How do you troubleshoot a Kubernetes application?
A: You can troubleshoot a Kubernetes application using the kubectl logs and kubectl describe commands.
Q13 [🚀 Expert] How do you optimize the performance of a Kubernetes application?
A: You can optimize the performance of a Kubernetes application using Horizontal Pod Autoscaling, Vertical Pod Autoscaling, and Cluster Autoscaling.
Q14 [🚀 Expert] How do you secure a Kubernetes cluster?
A: You can secure a Kubernetes cluster using Network Policies, Secrets, and ConfigMaps, as well as implementing proper access controls and monitoring.
Q15 [🚀 Expert] How do you upgrade a Kubernetes cluster?
A: You can upgrade a Kubernetes cluster using the kubectl upgrade command and following the official upgrade documentation.

5 [🏗️ System Design] — Architecture decisions at scale

Q16 [🏗️ System Design] How do you design a scalable Kubernetes application?

A: You can design a scalable Kubernetes application by using a microservices architecture, implementing load balancing and autoscaling, and using persistent storage.
Q17 [🏗️ System Design] How do you implement high availability in a Kubernetes application?
A: You can implement high availability in a Kubernetes application by using multiple replicas, implementing load balancing, and using persistent storage.
Q18 [🏗️ System Design] How do you secure a Kubernetes application at scale?
A: You can secure a Kubernetes application at scale by implementing proper access controls, using Network Policies and Secrets, and monitoring the application for security threats.
Q19 [🏗️ System Design] How do you optimize the performance of a Kubernetes application at scale?
A: You can optimize the performance of a Kubernetes application at scale by using Horizontal Pod Autoscaling, Vertical Pod Autoscaling, and Cluster Autoscaling, as well as implementing proper caching and load balancing.
Q20 [🏗️ System Design] How do you implement disaster recovery in a Kubernetes application?
A: You can implement disaster recovery in a Kubernetes application by using a Backup tool, such as Velero, and implementing proper disaster recovery procedures.

3 [⚠️ Interviewer Traps] — Questions that sound easy but catch overconfidence

Q21 [⚠️ Interviewer Traps] What is the difference between a Pod and a Container?

A: A Pod is a logical host for one or more containers, while a Container is a runtime environment for an application.
Q22 [⚠️ Interviewer Traps] How do you implement load balancing in a Kubernetes application?
A: You can implement load balancing in a Kubernetes application using a Service and a LoadBalancer.
Q23 [⚠️ Interviewer Traps] How do you troubleshoot a Kubernetes application that is not responding?
A: You can troubleshoot a Kubernetes application that is not responding by using the kubectl logs and kubectl describe commands, as well as checking the application's configuration and networking settings.

🏋️ Practice Exercises

Exercise 1 [🌱 Beginner] — Conceptual

What is the primary function of a Kubernetes Deployment?

A: The primary function of a Kubernetes Deployment is to manage and scale multiple Pods.

Exercise 2 [⚙️ Medium] — Build It

Create a Kubernetes Deployment YAML file that deploys a simple web application.

A: Create a YAML file with the following contents:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web-app
  template:
    metadata:
      labels:
        app: web-app
    spec:
      containers:
      - name: web-app
        image: nginx:latest
        ports:
        - containerPort: 80

Exercise 3 [🚀 Expert] — Debug This

A Kubernetes application is not responding, and the logs show a "Connection Refused" error. What could be the cause of this issue?

A: The cause of this issue could be a networking problem, such as a misconfigured Service or a missing Network Policy.

🗺️ Learning Path

Before This Topic (Prerequisites)

• Containerization (e.g., Docker)
• Container runtimes (e.g., Docker Engine)
• Networking fundamentals (e.g., IP addresses, ports)
• Basic Linux commands
• Familiarity with cloud platforms (e.g., AWS, GCP, Azure)

After This Topic (What to Learn Next)

• Advanced Kubernetes topics (e.g., Network Policies, Secrets, ConfigMaps)
• Kubernetes ecosystem tools (e.g., Prometheus, Grafana, Velero)
• Cloud-native application development (e.g., microservices architecture, service mesh)
• DevOps and CI/CD practices (e.g., Jenkins, GitLab CI/CD)

Related Topics

• Containerization (e.g., Docker)
• Container runtimes (e.g., Docker Engine)
• Networking fundamentals (e.g., IP addresses, ports)
• Basic Linux commands
• Cloud platforms (e.g., AWS, GCP, Azure)
• Cloud-native application development (e.g., microservices architecture, service mesh)
• DevOps and CI/CD practices (e.g., Jenkins, GitLab CI/CD)

📚 Glossary

• Kubernetes: An open-source container orchestration system.
• Pod: The basic execution unit in Kubernetes.
• Deployment: A way to manage and scale multiple Pods.
• Service: A way to expose an application to the outside world.
• Persistent Volume: A way to provide persistent storage for applications.
• ConfigMap: A way to store configuration data for applications.
• Secret: A way to store sensitive data for applications.
• Network Policy: A way to control traffic flow between Pods and services.
• Metrics: A way to collect metrics on application performance and resource utilization.
• Logs: A way to collect logs on application activity and errors.
• Traces: A way to collect traces on application requests and responses.

📋 Quick Reference Cheat Sheet

• Keyword: Kubernetes | Interview-ready fact: Kubernetes is an open-source container orchestration system. [🌱 Beginner]
• Keyword: Pod | Interview-ready fact: A Pod is the basic execution unit in Kubernetes. [🌱 Beginner]
• Keyword: Deployment | Interview-ready fact: A Deployment is a way to manage and scale multiple Pods. [⚙️ Medium]
• Keyword: Service | Interview-ready fact: A Service is a way to expose an application to the outside world. [🌱 Beginner]
• Keyword: Persistent Volume | Interview-ready fact: A Persistent Volume is a way to provide persistent storage for applications. [⚙️ Medium]
• Keyword: ConfigMap | Interview-ready fact: A ConfigMap is a way to store configuration data for applications. [⚙️ Medium]
• Keyword: Secret | Interview-ready fact: A Secret is a way to store sensitive data for applications. [🚀 Expert]
• Keyword: Network Policy | Interview-ready fact: A Network Policy is a way to control traffic flow between Pods and services. [🚀 Expert]
• Keyword: Metrics | Interview-ready fact: Metrics are a way to collect metrics on application performance and resource utilization. [⚙️ Medium]
• Keyword: Logs | Interview-ready fact: Logs are a way to collect logs on application activity and errors. [⚙️ Medium]
• Keyword: Traces | Interview-ready fact: Traces are a way to collect traces on application requests and responses. [🚀 Expert]
• Keyword: Horizontal Pod Autoscaling | Interview-ready fact: Horizontal Pod Autoscaling is a way to automatically scale the number of Pods based on resource utilization. [🚀 Expert]
• Keyword: Vertical Pod Autoscaling | Interview-ready fact: Vertical Pod Autoscaling is a way to automatically adjust the resources allocated to a Pod based on resource utilization. [🚀 Expert]
• Keyword: Cluster Autoscaling | Interview-ready fact: Cluster Autoscaling is a way to automatically scale the number of nodes in a cluster based on resource utilization. [🚀 Expert]
• Keyword: Resource Limits | Interview-ready fact: Resource Limits are a way to limit the amount of resources a Pod can consume. [⚙️ Medium]
• Keyword: Resource Requests | Interview-ready fact: Resource Requests are a way to request a specific amount of resources for a Pod. [⚙️ Medium]
• Keyword: Prometheus | Interview-ready fact: Prometheus is a monitoring system and time series database. [🚀 Expert]
• Keyword: Grafana | Interview-ready fact: Grafana is a visualization tool for metrics and logs. [🚀 Expert]
• Keyword: Velero | Interview-ready fact: Velero is a Backup tool for Kubernetes applications. [🚀 Expert]
• Keyword: High Availability | Interview-ready fact: High Availability is a way to ensure applications are always available. [⚙️ Medium]
• Keyword: Disaster Recovery | Interview-ready fact: Disaster Recovery is a way to ensure applications can recover from failures. [⚙️ Medium]