Amazon DevOps Engineer (Mid-Level) Interview Preparation Guide
Amazon's DevOps Engineer interview process for mid-level candidates typically consists of an initial recruiter screening followed by technical phone screens and multiple onsite interview rounds. The process evaluates technical proficiency in cloud infrastructure, CI/CD automation, containerization, system design, troubleshooting capabilities, and alignment with Amazon's Leadership Principles. Expect approximately 5-7 total rounds spanning 4-6 weeks from initial contact to offer decision.
Interview Rounds
Recruiter Screening
What to Expect
Initial recruiter call followed by a brief technical screening call with the hiring manager or senior team member. The first call (20-30 minutes) covers your background, career goals, understanding of the DevOps role, and basic questions about your technical experience. A second call 1-2 weeks later (15-20 minutes) may include quick technical questions to assess baseline knowledge before advancing to phone interviews. This round determines if you meet the baseline requirements and fit the team's needs.
Tips & Advice
Research Amazon's Leadership Principles before this call and be ready to speak to how your experience aligns with them. Prepare a 1-2 minute concise summary of your relevant DevOps experience, focusing on the complexity and impact (not just list of tools used). Ask thoughtful questions about the team's current infrastructure challenges, tech stack, and team dynamics. Mention specific AWS services you've worked with. Be enthusiastic about automation and infrastructure-as-code practices. Clarify the role's responsibilities and how it differs from pure SysOps or pure software engineering.
Focus Topics
Why DevOps and Why Amazon
Articulate what excites you about DevOps work specifically (automation, infrastructure, reliability, scale). Explain why you're interested in Amazon DevOps role and what you know about the company's infrastructure philosophy.
Practice Interview
Study Questions
Amazon Leadership Principles Overview
Understand Amazon's 16 Leadership Principles (Customer Obsession, Ownership, Invent and Simplify, Are Right A Lot, Learn and Be Curious, Hire and Develop the Best, Insist on Highest Standards, Think Big, Bias for Action, Frugality, Earn Trust, Dive Deep, Have Backbone; Disagree and Commit, Deliver Results, Strive for Operational Excellence). Be ready to discuss 2-3 principles with examples from your past work.
Practice Interview
Study Questions
AWS Services Familiarity
Be prepared to discuss your hands-on experience with core AWS services: EC2, S3, RDS, VPC, Lambda, ECS, EKS, CodePipeline, CloudFormation, CloudWatch, and IAM. Mention specific use cases where you used these services.
Practice Interview
Study Questions
Your DevOps Background and Motivations
Articulate your 2-5 years of DevOps experience with concrete examples of what you've built or improved. Explain what attracted you to DevOps as a career and why you're interested in Amazon specifically.
Practice Interview
Study Questions
Technical Phone Screen - AWS Fundamentals & Scripting
What to Expect
Technical phone interview (45-60 minutes) conducted by a senior DevOps engineer or engineer from the team. This round assesses foundational AWS knowledge, practical scripting ability, and basic system thinking. You may be asked to write scripts (Python, Bash, Go) to solve infrastructure problems or answer detailed questions about AWS services, networking, and deployment. Expect 2-3 coding/scripting problems and conceptual questions about infrastructure design. You'll use a shared code editor (CoderPad, HackerRank, or similar) to write code in real-time.
Tips & Advice
Choose a language you're most comfortable with (Python and Bash are especially valued for DevOps). For scripting problems, focus on correctness first, then optimization. Explain your approach before coding. Think out loud so the interviewer can follow your reasoning. When discussing AWS services, provide practical examples of when and why you'd use each service. Be prepared to explain the trade-offs in your solutions (e.g., cost vs. complexity, simplicity vs. robustness). For architecture questions, start simple and ask clarifying questions about requirements before diving into complexity. Mention monitoring, logging, and security considerations proactively.
Focus Topics
Infrastructure as Code (IaC) Concepts
Understand IaC principles: declarative vs. imperative approaches, version-controlled infrastructure, reproducibility, and idempotency. Familiarity with Terraform, CloudFormation, or Ansible. Understand how to structure IaC for maintainability and team collaboration.
Practice Interview
Study Questions
Docker and Container Basics
Understand Docker fundamentals: images, containers, Dockerfile syntax, image registry (ECR, Docker Hub), container networking, volumes. Know when containerization is appropriate and common patterns for containerized applications.
Practice Interview
Study Questions
Monitoring, Logging, and Observability Basics
Understand key metrics for infrastructure monitoring (CPU, memory, disk, network), logging concepts (structured logging, log aggregation), and observability tools. Familiarity with CloudWatch, ELK stack, Prometheus, Grafana, or similar tools.
Practice Interview
Study Questions
AWS EC2, RDS, S3, and VPC Fundamentals
Deep understanding of these core services: EC2 instance types and lifecycle, RDS multi-AZ vs. read replicas, S3 storage classes and access control, VPC networking including subnets, security groups, NATs, and route tables. Understand when to use each and common configuration patterns.
Practice Interview
Study Questions
Infrastructure Scripting (Python, Bash, or Go)
Write scripts to automate common infrastructure tasks: parsing logs, managing files, interacting with APIs, orchestrating deployments. Practice writing clean, efficient, error-handled scripts in your chosen language. Understand basic data structures, string manipulation, and system command execution.
Practice Interview
Study Questions
CI/CD Pipeline Basics
Understand the fundamentals of CI/CD: source control workflows (Git branching), build automation, testing in pipelines, artifact management, deployment strategies (blue-green, canary, rolling), and rollback procedures. Know popular tools: CodePipeline, CodeBuild, Jenkins, GitLab CI, GitHub Actions.
Practice Interview
Study Questions
Onsite Round 1 - Infrastructure System Design
What to Expect
45-60 minute system design interview where you design the infrastructure architecture for a given application scenario. You'll be given a problem statement (e.g., 'design infrastructure for a global SaaS application handling 1M requests per day' or 'design infrastructure for a microservices-based platform'). You're expected to draw diagrams, discuss AWS service choices, address scalability, fault tolerance, security, cost optimization, and disaster recovery. The interviewer may ask follow-up questions to dig deeper into your design decisions, trade-offs, and alternative approaches. You'll typically work on a whiteboard or digital drawing tool.
Tips & Advice
Start by clarifying requirements and constraints (traffic volume, latency requirements, data size, regional considerations, team size). Sketch an architecture diagram early, even if rough. Explain your reasoning for each service choice. Discuss multi-AZ deployment, auto-scaling, database strategy, CDN usage, and DNS failover. Address security explicitly (IAM, encryption, secrets management). Mention monitoring and logging from the start. Be prepared to defend your choices and discuss trade-offs (e.g., cost vs. complexity, simplicity vs. scalability). For a mid-level role, showing practical judgment (e.g., not defaulting to Kubernetes for simple workloads) is more valuable than choosing the 'most advanced' technologies. Ask clarifying questions throughout. Discuss cost implications and how you'd optimize. Mention disaster recovery and backup strategies. If you make assumptions, state them clearly.
Focus Topics
Networking and Security (VPC, Security Groups, IAM)
Design VPC architecture with appropriate subnets, security groups, and network ACLs. Implement least-privilege IAM policies. Understand network segmentation, VPN, and bastion hosts. Address encryption in-transit and at-rest.
Practice Interview
Study Questions
Scalability and Performance Optimization
Design for scalability: auto-scaling groups, load balancing (ALB, NLB), CDN distribution (CloudFront), database read replicas. Identify and address potential bottlenecks. Discuss caching strategies and connection pooling.
Practice Interview
Study Questions
Cost Optimization and Trade-offs
Discuss cost implications of architecture choices: reserved instances vs. spot instances, storage tiers, data transfer costs. Explain how to balance cost with performance and reliability. Show awareness of AWS Trusted Advisor and cost monitoring.
Practice Interview
Study Questions
Database Architecture (RDS, DynamoDB, Caching)
Design database strategies: when to use RDS (relational), DynamoDB (NoSQL), read replicas, multi-AZ failover. Understand caching strategies with ElastiCache. Know how to handle scaling, backup, and disaster recovery for databases.
Practice Interview
Study Questions
Multi-AZ High Availability Architecture
Design highly available systems using AWS Availability Zones: load balancing across AZs, multi-AZ RDS, auto-scaling groups spanning multiple AZs, regional failover strategies. Understand the trade-offs between availability, cost, and complexity.
Practice Interview
Study Questions
Compute Platform Selection (EC2, ECS, EKS, Lambda)
Understand when to use each compute option: EC2 for full control, ECS Fargate for containerized workloads without cluster management overhead, EKS for Kubernetes, Lambda for serverless. Know the trade-offs in terms of cost, operational overhead, and flexibility.
Practice Interview
Study Questions
Onsite Round 2 - CI/CD Pipeline Design and Implementation
What to Expect
45-60 minute technical interview focused on designing and implementing a CI/CD pipeline for a containerized application. You'll be asked to design an end-to-end pipeline from source control through production deployment, discuss tool choices (CodePipeline, Jenkins, GitLab CI, GitHub Actions), implement deployment strategies (blue-green, canary, rolling), handle testing, and address rollback capabilities. Interviewers may ask you to code parts of pipeline configuration or scripting logic. The focus is on automation, reliability, deployment safety, and operational excellence. You may be asked about GitOps practices and how you'd manage infrastructure manifests alongside application code.
Tips & Advice
Start by understanding the requirements: application type, deployment frequency, team size, infrastructure (VMs, containers, serverless). Design the pipeline stages: source, build, test, deploy to staging, deploy to production. Discuss your tool choices and why (AWS CodePipeline with CodeBuild and CodeDeploy is natural for AWS roles). Explain how you'd handle secrets, artifact management, and versioning. Discuss automated testing at each stage (unit, integration, smoke tests). Explain your deployment strategy and why it's appropriate for the scenario. Address how you'd monitor deployments and implement automatic rollbacks on failure. For containerized apps, discuss ECR integration and image scanning. Mention how you'd handle database migrations safely. Discuss the balance between automation and safety gates (automated tests vs. manual approvals). If you mention GitOps, explain how Git becomes the source of truth and how tools like ArgoCD handle deployment reconciliation. Discuss how you'd implement blue-green or canary deployments specifically.
Focus Topics
Automated Testing in CI/CD Pipelines
Design testing stages: unit tests, integration tests, smoke tests, security scanning, performance tests. Understand testing frameworks and how to integrate tests into the pipeline. Know when to fail fast and when to allow manual approval.
Practice Interview
Study Questions
Secrets Management and Configuration in CI/CD
Manage secrets securely in CI/CD: environment variables, CI/CD platform secrets storage (GitHub Actions secrets, CodePipeline parameter store), Vault integration, HashiCorp Vault, AWS Secrets Manager. Understand how to inject secrets at build/deploy time without exposing them.
Practice Interview
Study Questions
GitOps Principles and Implementation
Understand GitOps: Git as single source of truth, declarative infrastructure, automated reconciliation, continuous deployment via Git commits. Tools like ArgoCD, Flux. How to structure repos for environment promotion (dev -> staging -> prod). How to handle emergency overrides.
Practice Interview
Study Questions
CI/CD Pipeline Architecture and Tool Selection
Design complete CI/CD pipelines: source control integration, build automation, testing stages, artifact management, deployment automation. Understand tools like AWS CodePipeline, CodeBuild, CodeDeploy, Jenkins, GitLab CI, GitHub Actions. Know when to choose each and their strengths/limitations.
Practice Interview
Study Questions
Containerized Application Deployment (Docker, ECR, ECS, EKS)
Design deployment strategies for containerized applications: Docker image building and scanning, ECR registry management, ECS vs. EKS deployment approaches, health checks and auto-recovery, service discovery, and load balancing.
Practice Interview
Study Questions
Deployment Strategies (Blue-Green, Canary, Rolling)
Understand and implement different deployment strategies: blue-green deployments for zero-downtime releases, canary deployments to reduce risk by gradual rollout, rolling deployments for gradual instance replacement. Know the trade-offs of each approach and when to use them.
Practice Interview
Study Questions
Onsite Round 3 - Troubleshooting and Incident Response
What to Expect
30-45 minute technical interview simulating a production incident. You may be presented with a live or simulated infrastructure issue (e.g., 'a service became unreachable 5 minutes ago', 'pods are crash-looping in your Kubernetes cluster', 'deployment is stuck', 'latency spiked unexpectedly'). You'll be asked to diagnose the root cause using systematic troubleshooting, demonstrate knowledge of diagnostic tools, and identify whether the issue is infrastructure, deployment, or dependency-related. You may have access to logs, metrics dashboards, terminal access to servers, or Kubernetes API. The focus is on methodology, not just arriving at the correct answer. Interviewers want to see how you think through problems under pressure and how you communicate your investigation process.
Tips & Advice
Approach troubleshooting systematically: don't jump to conclusions, follow a logical investigation path. Start by gathering information: when did the issue start, what changed recently, what are the symptoms? Check the four golden signals (latency, traffic, errors, saturation) across services. Use a structured approach: (1) Is it deployment-related (check recent deployments, rollback if necessary)? (2) Are dashboards showing anomalies (check CloudWatch, Prometheus)? (3) Are dependencies healthy (database, external APIs, DNS, certificates)? (4) Check logs for error patterns. Communicate your thinking aloud so the interviewer can follow your logic. Avoid random guessing; each action should have a clear reason. If you identify multiple potential causes, prioritize by likelihood. Practice common Kubernetes debugging: checking pod status, logs, describe pod output, events. Practice Linux/infrastructure debugging: disk space, file descriptors, connections, resource contention. Know how to use tools: SSH into instances, tail logs, use curl for API testing, check DNS resolution, verify IAM permissions. Be prepared to discuss how you'd prevent this issue in the future (monitoring alerts, automated rollback, circuit breakers). Mention communication during incidents: notifying stakeholders, updating status pages.
Focus Topics
Linux/Infrastructure Debugging Tools and Commands
Proficiency with Linux debugging: SSH access, viewing logs (tail, grep), checking system resources (top, htop, df, du), network diagnostics (netstat, ss, curl, dig), process management, file permissions, disk usage analysis.
Practice Interview
Study Questions
Incident Communication and Resolution Strategy
During an incident: prioritize mitigation over diagnosis (e.g., scale up before analyzing root cause), communicate to stakeholders regularly, implement temporary fixes while investigating root cause, document the timeline and findings, discuss how to prevent recurrence through monitoring alerts and automation.
Practice Interview
Study Questions
Log Analysis and Debugging
Analyze logs to find root causes: application logs, system logs, access logs. Use log aggregation tools (CloudWatch Logs, ELK, Splunk). Search for error patterns, exceptions, warnings. Correlate logs across multiple services and timestamps.
Practice Interview
Study Questions
Kubernetes Troubleshooting (Pod Status, Logs, Events)
Debug Kubernetes issues: understand pod lifecycle and states, use kubectl logs and describe commands, analyze events for clues. Common issues: CrashLoopBackOff, ImagePullBackOff, pending pods, resource constraints, readiness/liveness probe failures.
Practice Interview
Study Questions
Application and Infrastructure Monitoring Interpretation
Interpret metrics and dashboards: CPU, memory, disk, network, application-level metrics (request rate, latency, error rate). Use CloudWatch, Prometheus, Grafana. Understand the four golden signals and how to identify anomalies. Know how to correlate metrics with events.
Practice Interview
Study Questions
Systematic Incident Investigation Approach
Troubleshoot using a structured process: (1) gather information about when issue started and what changed, (2) check deployment-related issues first, (3) examine dashboards and metrics, (4) investigate dependencies (database, external APIs, DNS), (5) analyze logs for patterns, (6) identify root cause vs. symptoms. Document findings and communicate throughout.
Practice Interview
Study Questions
Onsite Round 4 - Technical Deep Dive and Past Experience
What to Expect
45-60 minute interview focused on your past infrastructure projects and technical depth. Come prepared with 3-4 detailed infrastructure projects you've owned or significantly contributed to. For each project, be ready to discuss: what problem you were solving, why you chose specific technologies, how you designed the solution, what went wrong (be honest about failures), what you learned, and what you'd do differently today. Expect deep follow-up questions on specific technical decisions, trade-offs you made, how you handled complexity, how you collaborated with teams, and how you measured success. This round evaluates your depth of knowledge, ability to make sound architectural decisions, and learning from experience.
Tips & Advice
Prepare detailed project narratives with specific metrics: infrastructure size (number of servers, users served, requests per second, data volume), business impact (cost savings, performance improvements, uptime increase), timeline, and team size. Use the STAR method but go deeper: dive into why you made specific technical choices, what trade-offs you considered, and what alternatives you rejected and why. Be honest about failures and challenges; interviewers appreciate learning mindset more than claiming perfection. Discuss one project that didn't go perfectly and what you learned. Quantify your impact: 'reduced deployment time from 2 hours to 15 minutes', 'improved uptime from 99.5% to 99.95%', 'reduced cloud costs by 40%'. Be ready to explain complex architectural decisions in detail. If you mention using a particular tool or pattern, be prepared to defend why it was the right choice and when you'd use something different. Discuss how you collaborated with development teams, security, and other stakeholders. Show evidence of seeking feedback and continuous improvement. Mention monitoring, logging, and operational excellence aspects of your projects.
Focus Topics
Infrastructure Modernization and Migration Projects
Discuss projects where you modernized or migrated infrastructure: VM to container migration, monolith to microservices support, legacy to cloud, on-premises to AWS. Include challenges faced, how you managed risk, and outcomes achieved.
Practice Interview
Study Questions
Handling Failures and Learning from Incidents
Honestly discuss a major incident or project failure: what went wrong, how you responded, what you learned, and how you prevented recurrence. Show growth mindset and accountability rather than blame.
Practice Interview
Study Questions
Scaling and Performance Optimization Work
Discuss projects where you scaled infrastructure to handle growth: moving from single-instance to multi-AZ, containerizing legacy applications, migrating to Kubernetes, optimizing database queries, implementing caching. Include specific before/after metrics.
Practice Interview
Study Questions
Cost Optimization and Efficiency Improvements
Share examples where you reduced infrastructure costs: right-sizing instances, implementing reserved instances or savings plans, optimizing storage tiers, eliminating unused resources. Include the magnitude of savings and how you measured them.
Practice Interview
Study Questions
End-to-End Infrastructure Project Ownership
Discuss infrastructure projects you've owned from design to production operation: requirements gathering, architectural design, implementation, deployment, and ongoing operations. Include what metrics you used to measure success and how you handled operational challenges.
Practice Interview
Study Questions
Technical Decision-Making and Trade-offs
Explain architectural decisions you've made: why you chose specific AWS services over alternatives, when you chose complexity for a business reason, when you chose simplicity over features, cost vs. performance trade-offs. Show that you make intentional choices, not default selections.
Practice Interview
Study Questions
Onsite Round 5 - Behavioral Interview and Amazon Leadership Principles
What to Expect
45-60 minute behavioral interview conducted by a hiring manager or senior team member. This round evaluates your alignment with Amazon's Leadership Principles and your cultural fit with the organization. You'll be asked behavioral questions about past experiences: how you've handled conflict, made decisions, learned from failure, collaborated across teams, driven results, and showed ownership. The interviewer will dig deep into your answers with follow-up questions to understand your values and decision-making process. This is as important as technical rounds for Amazon; the company prioritizes culture fit and leadership alignment highly.
Tips & Advice
Prepare stories using the STAR method (Situation, Task, Action, Result) that map to Amazon's Leadership Principles. For each of these principles prepare at least one story: Ownership (took responsibility for a project outcome), Bias for Action (made quick decisions when information was incomplete), Learn and Be Curious (approached a new technology or skill with enthusiasm), Earn Trust (gained credibility through consistent delivery), Deliver Results (achieved measurable outcomes despite obstacles), Insist on Highest Standards (maintained quality even under pressure). Use specific examples with quantifiable results. When asked about failure, be honest but show what you learned. Avoid blaming others; focus on what you could have done differently. Ask clarifying questions if a behavioral question is unclear. Connect your answers back to how you'd apply those principles in the DevOps role. Show evidence of collaboration and cross-functional thinking, not just individual achievement. Discuss how you've mentored or supported junior colleagues, showing leadership potential. Be genuine; interviewers detect prepared answers but appreciate authentic examples. Prepare questions about the team, culture, and how they approach DevOps to show genuine interest.
Focus Topics
Handling Disagreement and Conflict Resolution
Show how you handle disagreement professionally. Story should demonstrate a time you disagreed with a colleague or manager, how you communicated your perspective, and how you reached resolution while maintaining relationships.
Practice Interview
Study Questions
Amazon Leadership Principle: Learn and Be Curious
Show willingness to learn new technologies and skills. Story should demonstrate self-directed learning, picking up new tools or concepts, diving deep into understanding infrastructure, or approaching challenges with curiosity rather than assumptions.
Practice Interview
Study Questions
Amazon Leadership Principle: Earn Trust
Build credibility through reliability and integrity. Story should show how you gained trust of teammates, maintained confidentiality, followed through on commitments, or became the person people relied on during crises.
Practice Interview
Study Questions
Amazon Leadership Principle: Bias for Action
Make decisions and take action even with incomplete information. Story should demonstrate a time you made a quick decision to mitigate a production issue, deployed a change to improve operations, or took initiative without waiting for perfect information.
Practice Interview
Study Questions
Amazon Leadership Principle: Ownership
Take responsibility for outcomes rather than just tasks. Story should show how you took ownership of an infrastructure project, drove it to completion, and felt accountable for results even when facing obstacles or stakeholder challenges.
Practice Interview
Study Questions
Amazon Leadership Principle: Deliver Results
Focus on outcomes and measurable results. Story should quantify impact: uptime improvement, cost savings, reduced deployment time. Show how you balanced short-term pressure with long-term quality and persisted through obstacles.
Practice Interview
Study Questions
Frequently Asked DevOps Engineer Interview Questions
Sample Answer
Sample Answer
name: deploy
on: [workflow_dispatch]
jobs:
deploy:
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v3
- name: Deploy to cluster
uses: google-github-actions/auth@v1
with: ...
- name: kubectl apply
run: kubectl apply -f k8s/${{ inputs.env }}/deployment.yaml --recordSample Answer
kubectl describe pod <pod> -n <ns>
kubectl get events -n <ns> --sort-by='.lastTimestamp'
kubectl logs <pod> -n <ns> --all-containers=true --previouskubectl describe pod <pod> -n <ns> | sed -n '/Events:/,$p'
# check node docker/containerd logs
ssh <node>
sudo journalctl -u kubelet -f
sudo journalctl -u containerd -f # or docker
sudo crictl pull <image> # test pull from nodekubectl get pvc -n <ns> -o wide
kubectl describe pvc <pvc> -n <ns>
kubectl get pv
# CSI driver pods
kubectl get pods -n kube-system -l 'app in (csi,ebs-csi,aws-ebs-csi-driver)'
kubectl logs -n kube-system <csi-pod> --container=<csi-container> --follow
# check CSI node daemonset logs on node
ssh <node>
sudo journalctl -u kubelet -g csi -f
# check attach/mount on node filesystem
ls -la /var/lib/kubelet/pods/<podUID>/volumeskubectl get nodes -o wide
kubectl describe node <node>
ssh <node>
sudo journalctl -u kubelet -n 200
sudo systemctl status kubelet
# inspect kubelet plugin-dir
ls -la /var/lib/kubelet/pluginskubectl get pods -n kube-system -l k8s-app=kube-flannel,app=calico --no-headers
ssh <node>
sudo journalctl -u kubelet -g cni -f
ls /var/lib/cni/
cat /etc/cni/net.d/*.confSample Answer
post-processor "manifest" {
output = "manifest.json"
}aws ssm put-parameter --name /images/myapp/candidate --value "$AMI_ID" --type String --overwriteSample Answer
Sample Answer
Sample Answer
import hmac, hashlib
def in_bucket(user_id, feature_key, salt_version, pct):
key = f"{feature_key}:{user_id}".encode()
h = hmac.new(salt_version.encode(), key, hashlib.sha256).digest()
val = int.from_bytes(h[:4], 'big') % 10000
return val < int(pct * 100)
# usage: in_bucket("user123", "new_ui", "v1", 20.0)Sample Answer
Sample Answer
kubectl describe node <node> # eviction events, DiskPressure taint
kubectl get nodes -o wide
journalctl -u kubelet -n 200ssh node
df -h /
du -sh /var/lib/kubelet/* | sort -hkubectl top node --containers # if metrics-server supports
kubectl get pod -A -o jsonpath='{range .items[*]}{.metadata.namespace} {.metadata.name} {.status.containerStatuses[*].name} {.status.containerStatuses[*].restartCount}{"\n"}{end}'
# On node:
du -sh /var/log/containers | sort -hls -la /var/lib/kubelet/pods | grep -vF "$(kubectl get pods -A -o jsonpath='{range .items[*]}{.metadata.uid}{"\n"}{end}')"
# or use kubelet volume stats/CSI garbage collection logskubectl cordon <node>
kubectl drain <node> --ignore-daemonsets --delete-local-data --force # if safe for workloadssystemctl restart kubelet--eviction-hard=memory.available<100Mi,nodefs.available<10%
--eviction-soft=nodefs.available<15%,... --eviction-soft-period=2mSample Answer
Want to create your own tailored preparation guide using our deep research?
Get Started for FreeInterview-Ready Courses
Visual-first, interactive, structured learning paths