Kompletny Przewodnik - Rozmowa Rekrutacyjna DevOps Engineer 2026

Rozmowa na stanowisko DevOps Engineer w 2026 roku to nie jest już tylko "napisz Dockerfile i skonfiguruj Jenkins". To sprawdzian z całego ekosystemu - od konteneryzacji i orkiestracji, przez automatyzację infrastruktury, cloud, aż po monitoring i bezpieczeństwo. Kandydaci, którzy przychodzą znając tylko podstawy Dockera, odpadają na pytaniach o Kubernetes czy Terraform.

W tym przewodniku znajdziesz kompletną mapę tego, co sprawdzają rekruterzy na rozmowach DevOps, jakie pytania padają najczęściej, i jak się do nich przygotować. Każda sekcja zawiera linki do szczegółowych artykułów, gdzie znajdziesz konkretne pytania z odpowiedziami.

Co sprawdzają na rozmowie DevOps Engineer

Zanim zagłębimy się w szczegóły, musisz zrozumieć strukturę tego, co rekruterzy oceniają. Rozmowa DevOps/SRE składa się z siedmiu głównych obszarów:

Obszar	Waga	Co sprawdzają
Konteneryzacja	20-25%	Docker, Docker Compose, obrazy, wolumeny, sieci
Orkiestracja	20-25%	Kubernetes, Helm, deployments, services, skalowanie
CI/CD	15-20%	GitHub Actions, GitLab CI, Jenkins, pipelines, automatyzacja
Linux/Bash	10-15%	Komendy, scripting, procesy, filesystem, networking
Cloud	10-15%	AWS/Azure/GCP, IaC (Terraform, Pulumi), networking
Monitoring	5-10%	Prometheus, Grafana, ELK, alerting, observability
Bezpieczeństwo	5-10%	Secrets, RBAC, scanning, hardening

Wagi różnią się między firmami. Startupy mogą kłaść większy nacisk na szybkie wdrożenia i Docker. Korporacje często sprawdzają głębiej Kubernetes i architekturę. Firmy cloud-native oczekują zaawansowanej wiedzy o AWS/GCP. Ale konteneryzacja z Dockerem jest fundamentem wszędzie - bez zrozumienia jak działają kontenery, cała reszta się wali.

Konteneryzacja - Fundament DevOps

Możesz być ekspertem od Kubernetes, ale jeśli nie potrafisz wyjaśnić jak działa Docker, różnicę między COPY a ADD, czy zoptymalizować rozmiar obrazu, rozmowa skończy się szybko. Konteneryzacja to fundament i rekruterzy zaczynają właśnie od niej.

Docker - Najważniejszy Temat

Docker zrewolucjonizował sposób budowania, dystrybucji i uruchamiania aplikacji. Musisz rozumieć nie tylko "jak uruchomić kontener", ale całą filozofię:

# Klasyczne pytanie: co jest nie tak z tym Dockerfile?
FROM node:20
WORKDIR /app
COPY . .
RUN npm install
EXPOSE 3000
CMD ["node", "server.js"]

# Problemy:
# 1. Nie pinowana wersja (latest)
# 2. Brak .dockerignore
# 3. Słaby cache (COPY . przed npm install)
# 4. Brak USER (działa jako root)
# 5. Brak multi-stage build

Kontenery vs VM - musisz znać fundamentalną różnicę. Kontenery współdzielą kernel z hostem i izolują procesy, VM wirtualizuje całe hardware. Kontenery są szybsze i lżejsze, VM oferują silniejszą izolację.

Warstwy obrazu - każda instrukcja w Dockerfile tworzy warstwę. Warstwy są cache'owane i współdzielone. Zrozumienie tego jest kluczowe do optymalizacji.

Więcej pytań i odpowiedzi znajdziesz w artykule: Docker - Pytania Rekrutacyjne

Multi-stage Builds - Optymalizacja Obrazów

Multi-stage build to kluczowa technika redukująca rozmiar obrazów produkcyjnych:

# Stage 1: Build
FROM node:20 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Stage 2: Production
FROM node:20-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
USER node
CMD ["node", "dist/server.js"]

Korzyści:

• Obraz 150 MB zamiast 1.2 GB
• Brak narzędzi developerskich w produkcji
• Mniejsza powierzchnia ataku

Docker Compose - Wielokontenerowe Aplikacje

Docker Compose to standard dla lokalnego developmentu:

version: '3.8'
services:
  api:
    build: ./api
    ports:
      - "3000:3000"
    environment:
      - DB_HOST=postgres
    depends_on:
      postgres:
        condition: service_healthy

  postgres:
    image: postgres:15
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready"]
      interval: 5s

volumes:
  postgres_data:

Ważne kwestie:

• depends_on nie czeka na gotowość - użyj healthchecks
• Wolumeny dla persystencji danych
• Sieci dla izolacji usług

Orkiestracja - Kubernetes

Kubernetes to de facto standard dla produkcyjnych deploymentów kontenerów. W 2026 roku znajomość K8s jest praktycznie wymagana.

Podstawowe Koncepcje

# Deployment - zarządzanie replikami
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api
spec:
  replicas: 3
  selector:
    matchLabels:
      app: api
  template:
    metadata:
      labels:
        app: api
    spec:
      containers:
      - name: api
        image: myapp:v1.0
        ports:
        - containerPort: 3000
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "200m"
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10

Kluczowe obiekty:

• Pod - najmniejsza jednostka, jeden lub więcej kontenerów
• Deployment - zarządza replikami, rolling updates
• Service - load balancing, service discovery
• Ingress - routing HTTP(S) z zewnątrz
• ConfigMap/Secret - konfiguracja i sekrety

Service i Ingress

# Service - wewnętrzny load balancer
apiVersion: v1
kind: Service
metadata:
  name: api-service
spec:
  selector:
    app: api
  ports:
  - port: 80
    targetPort: 3000
  type: ClusterIP

---
# Ingress - zewnętrzny routing
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: api-ingress
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
spec:
  rules:
  - host: api.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: api-service
            port:
              number: 80

Typy Service:

• ClusterIP - wewnętrzny (domyślny)
• NodePort - dostęp przez port na nodzie
• LoadBalancer - external load balancer (cloud)

Helm - Package Manager dla K8s

# Instalacja aplikacji
helm install myapp ./charts/myapp -f values-prod.yaml

# Upgrade
helm upgrade myapp ./charts/myapp --set image.tag=v2.0

# Rollback
helm rollback myapp 1

Helm pozwala parametryzować manifesty i zarządzać releases - kluczowe dla większych deploymentów.

Więcej pytań i odpowiedzi z Kubernetes znajdziesz w artykule: Kubernetes - Pytania Rekrutacyjne

CI/CD - Automatyzacja

CI/CD to serce DevOps. Rekruterzy sprawdzają znajomość pipeline'ów, strategii deploymentu i best practices.

GitHub Actions - Pipeline

name: CI/CD Pipeline

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '20'
      - run: npm ci
      - run: npm test

  build:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: docker/build-push-action@v5
        with:
          push: true
          tags: myrepo/myapp:${{ github.sha }}

  deploy:
    needs: build
    if: github.ref == 'refs/heads/main'
    runs-on: ubuntu-latest
    steps:
      - name: Deploy to Kubernetes
        run: |
          kubectl set image deployment/api \
            api=myrepo/myapp:${{ github.sha }}

Strategie Deploymentu

Strategia	Opis	Kiedy używać
Rolling	Stopniowa wymiana pods	Domyślna, brak downtime
Blue-Green	Dwa identyczne środowiska	Instant rollback
Canary	% ruchu na nową wersję	Testowanie na produkcji
Recreate	Usuń wszystko, utwórz nowe	Brak wymogów HA

# Rolling update w Kubernetes
spec:
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0

Więcej pytań i odpowiedzi z CI/CD znajdziesz w artykule: CI/CD - Pytania Rekrutacyjne

Linux i Bash - Fundament

Każdy DevOps Engineer musi być sprawny w Linux. Rekruterzy sprawdzają praktyczne umiejętności.

Kluczowe Komendy

# Procesy
ps aux | grep nginx
top / htop
kill -9 <PID>
systemctl status nginx

# Pliki i katalogi
find /var/log -name "*.log" -mtime +7 -delete
grep -r "ERROR" /var/log/
tail -f /var/log/syslog
du -sh /var/*

# Sieć
netstat -tulpn
ss -tulpn
curl -I https://api.example.com
dig example.com
tcpdump -i eth0 port 80

# Uprawnienia
chmod 755 script.sh
chown www-data:www-data /var/www

Bash Scripting

#!/bin/bash
set -euo pipefail

# Skrypt backup
BACKUP_DIR="/backups"
DATE=$(date +%Y%m%d_%H%M%S)

for db in $(psql -l -t | cut -d'|' -f1 | grep -v template); do
  pg_dump "$db" > "${BACKUP_DIR}/${db}_${DATE}.sql"

  if [ $? -eq 0 ]; then
    echo "Backup $db completed"
    gzip "${BACKUP_DIR}/${db}_${DATE}.sql"
  else
    echo "Backup $db failed" >&2
    exit 1
  fi
done

# Cleanup old backups (older than 7 days)
find "$BACKUP_DIR" -name "*.sql.gz" -mtime +7 -delete

Więcej pytań i odpowiedzi z Linux/Bash znajdziesz w artykule: Linux - Pytania Rekrutacyjne

Cloud - AWS/Azure/GCP

Znajomość przynajmniej jednego cloud providera jest wymagana. AWS dominuje na rynku.

Infrastructure as Code - Terraform

# main.tf
provider "aws" {
  region = "eu-west-1"
}

resource "aws_vpc" "main" {
  cidr_block = "10.0.0.0/16"

  tags = {
    Name = "main-vpc"
  }
}

resource "aws_instance" "web" {
  ami           = "ami-0123456789"
  instance_type = "t3.micro"
  subnet_id     = aws_subnet.public.id

  tags = {
    Name = "web-server"
  }
}

# Outputs
output "instance_ip" {
  value = aws_instance.web.public_ip
}

terraform init
terraform plan
terraform apply
terraform destroy

Kluczowe Usługi AWS

Usługa	Opis	Odpowiednik Azure/GCP
EC2	Virtual Machines	VM / Compute Engine
S3	Object Storage	Blob / Cloud Storage
RDS	Managed Database	SQL Database / Cloud SQL
EKS	Managed Kubernetes	AKS / GKE
Lambda	Serverless Functions	Functions / Cloud Functions
VPC	Virtual Network	VNet / VPC

Więcej pytań i odpowiedzi z AWS znajdziesz w artykule: AWS - Pytania Rekrutacyjne

Monitoring i Observability

Monitoring to trzeci filar DevOps (obok Dev i Ops). Musisz znać podstawy.

Prometheus i Grafana

# prometheus.yml
global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'kubernetes-pods'
    kubernetes_sd_configs:
      - role: pod
    relabel_configs:
      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
        action: keep
        regex: true

# Przykładowe zapytania PromQL
# CPU usage per pod
rate(container_cpu_usage_seconds_total[5m])

# Memory usage percentage
container_memory_usage_bytes / container_spec_memory_limit_bytes * 100

# HTTP request rate
rate(http_requests_total[5m])

# Error rate
sum(rate(http_requests_total{status=~"5.."}[5m]))
  / sum(rate(http_requests_total[5m])) * 100

Three Pillars of Observability

Pillar	Narzędzia	Co daje
Logs	ELK, Loki, CloudWatch	Co się stało
Metrics	Prometheus, DataDog	Jak system się zachowuje
Traces	Jaeger, Zipkin	Jak flow przechodzi przez system

Bezpieczeństwo DevOps (DevSecOps)

Bezpieczeństwo musi być wbudowane w każdy etap pipeline.

Secrets Management

# ❌ Nigdy nie rób tak
env:
  - name: DB_PASSWORD
    value: "super-secret"

# ✅ Kubernetes Secrets
env:
  - name: DB_PASSWORD
    valueFrom:
      secretKeyRef:
        name: db-credentials
        key: password

# ✅ External Secrets Operator + Vault/AWS Secrets Manager
apiVersion: external-secrets.io/v1beta1
kind: ExternalSecret
metadata:
  name: db-credentials
spec:
  secretStoreRef:
    name: vault-backend
    kind: SecretStore
  target:
    name: db-credentials
  data:
    - secretKey: password
      remoteRef:
        key: secret/db
        property: password

Container Scanning

# Trivy - popularne narzędzie
trivy image myapp:v1.0

# W pipeline
- name: Scan image
  run: |
    trivy image --exit-code 1 --severity HIGH,CRITICAL myapp:${{ github.sha }}

Plan Przygotowania

Oto sugerowany plan przygotowania do rozmowy DevOps:

Tydzień 1-2: Konteneryzacja

• Docker fundamentals, Dockerfile, multi-stage
• Docker Compose, networking, volumes
• Bezpieczeństwo kontenerów

Tydzień 3-4: Kubernetes

• Podstawowe obiekty (Pod, Deployment, Service)
• Konfiguracja (ConfigMap, Secret)
• Networking (Ingress, NetworkPolicy)
• Helm basics

Tydzień 5: CI/CD

• GitHub Actions / GitLab CI
• Strategie deploymentu
• Automatyzacja testów

Tydzień 6: Cloud i IaC

• AWS/Azure/GCP podstawy
• Terraform fundamentals
• Networking w cloud

Na bieżąco: Praktyka

• Linux/bash codziennie
• Monitoring setup
• Security best practices

Zobacz też

• Docker - Pytania Rekrutacyjne - 42 pytania z odpowiedziami
• Kubernetes - Pytania Rekrutacyjne - 60+ pytań o K8s, Pods, Services i Helm
• Linux - Pytania Rekrutacyjne - 50+ pytań o komendy, procesy i bash scripting
• Networking - Pytania Rekrutacyjne - 50+ pytań o TCP/IP, DNS, HTTP, Load Balancing
• AWS - Pytania Rekrutacyjne - 55+ pytań o EC2, S3, VPC, IAM, Lambda
• Azure - Pytania Rekrutacyjne - 50+ pytań o VMs, App Service, Azure AD, AKS
• GCP - Pytania Rekrutacyjne - 50+ pytań o Compute Engine, GKE, BigQuery
• CI/CD - Pytania Rekrutacyjne - 60+ pytań o GitHub Actions, GitLab CI, Jenkins
• Kafka - Pytania Rekrutacyjne - 50+ pytań o topics, partitions, consumer groups, exactly-once
• Monitoring i Observability - 50+ pytań o Prometheus, Grafana, ELK, SLI/SLO
• Wzorce i Architektura Backend - mikrousługi i konteneryzacja

---

Ten artykuł jest częścią serii przygotowującej do rozmów rekrutacyjnych na stanowisko DevOps Engineer. Sprawdź nasze fiszki z pytaniami i odpowiedziami do nauki: Docker.