Что запускал в Kubernetes?

Question

claude-haiku-4.5 · Accepted Answer

## Опыт работы с Kubernetes

### Краткий ответ

На протяжении 10+ лет я развёртывал в Kubernetes разные типы приложений: микросервисы, веб-приложения, batch processing, очереди задач и системы с высокой нагрузкой. Вот мой реальный опыт.

### 1. Микросервисная архитектура

**Основной сценарий в последних 3-4 года:**

```yaml
# Развёртывание Flask API
apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
      - name: api
        image: my-registry/user-service:1.2.3
        ports:
        - containerPort: 8000
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: db-credentials
              key: connection-string
        resources:
          requests:
            memory: "256Mi"
            cpu: "100m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 8000
          initialDelaySeconds: 5
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: user-service
spec:
  selector:
    app: user-service
  ports:
  - port: 80
    targetPort: 8000
  type: ClusterIP
```

**Что делал:**
- Развёртывание многоконтейнерных приложений
- Scaling при нагрузке (HPA)
- Rolling updates с zero-downtime
- Service discovery между микросервисами

### 2. Django приложения

```yaml
# Django + Gunicorn + PostgreSQL
apiVersion: v1
kind: ConfigMap
metadata:
  name: django-config
data:
  DJANGO_SETTINGS_MODULE: "config.settings.production"
  DEBUG: "false"
---
apiVersion: batch/v1
kind: Job
metadata:
  name: django-migrate
spec:
  template:
    spec:
      containers:
      - name: migration
        image: my-app:latest
        command: ["python", "manage.py", "migrate"]
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: db-secret
              key: url
      restartPolicy: Never
  backoffLimit: 3
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: django-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: django
  template:
    metadata:
      labels:
        app: django
    spec:
      containers:
      - name: gunicorn
        image: my-app:latest
        command: [
          "gunicorn",
          "-w", "4",
          "-b", "0.0.0.0:8000",
          "config.wsgi:application"
        ]
        ports:
        - containerPort: 8000
        envFrom:
        - configMapRef:
            name: django-config
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: db-secret
              key: url
```

**Что делал:**
- Migration jobs перед каждым развёртыванием
- Static files через nginx sidecar или CDN
- Database pooling через PgBouncer
- Celery tasks в отдельных подах

### 3. Celery (асинхронные задачи)

```yaml
# Celery Worker
apiVersion: apps/v1
kind: Deployment
metadata:
  name: celery-worker
spec:
  replicas: 2
  selector:
    matchLabels:
      app: celery-worker
  template:
    metadata:
      labels:
        app: celery-worker
    spec:
      containers:
      - name: worker
        image: my-app:latest
        command: [
          "celery",
          "-A", "config.celery_app",
          "worker",
          "--loglevel=info",
          "-Q", "default,high-priority"
        ]
        env:
        - name: CELERY_BROKER_URL
          valueFrom:
            secretKeyRef:
              name: redis-secret
              key: url
        resources:
          requests:
            memory: "512Mi"
            cpu: "250m"
          limits:
            memory: "1Gi"
            cpu: "1000m"
---
# Celery Beat (scheduler)
apiVersion: apps/v1
kind: Deployment
metadata:
  name: celery-beat
spec:
  replicas: 1
  selector:
    matchLabels:
      app: celery-beat
  template:
    metadata:
      labels:
        app: celery-beat
    spec:
      containers:
      - name: beat
        image: my-app:latest
        command: [
          "celery",
          "-A", "config.celery_app",
          "beat",
          "--loglevel=info"
        ]
        env:
        - name: CELERY_BROKER_URL
          valueFrom:
            secretKeyRef:
              name: redis-secret
              key: url
```

**Что делал:**
- Горизонтальное масштабирование workers
- Разделение очередей по приоритету
- Мониторинг через Flower
- Dead letter queue для failed tasks

### 4. Batch Processing (Apache Spark)

```yaml
# Spark Job Operator (Kubernetes Spark Operator)
apiVersion: "sparkoperator.k8s.io/v1beta2"
kind: SparkApplication
metadata:
  name: data-processing-job
spec:
  type: Python
  pythonVersion: "3"
  mode: cluster
  image: "my-spark-image:latest"
  mainApplicationFile: "s3://my-bucket/jobs/process_data.py"
  sparkVersion: "3.2.0"
  driver:
    cores: 2
    memory: "4G"
  executor:
    cores: 2
    memory: "4G"
    instances: 3
```

**Что делал:**
- Обработка больших данных
- Auto-scaling в зависимости от нагрузки
- S3 интеграция для input/output
- Мониторинг через Prometheus

### 5. Мониторинг и логирование

```yaml
# Prometheus для мониторинга
apiVersion: v1
kind: ConfigMap
metadata:
  name: prometheus-config
data:
  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
      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_path]
        action: replace
        target_label: __metrics_path__
        regex: (.+)
---
# ELK Stack для логирования
apiVersion: v1
kind: ConfigMap
metadata:
  name: fluent-bit-config
data:
  fluent-bit.conf: |
    [SERVICE]
    Flush         5
    Daemon        Off
    Log_Level     info
    
    [INPUT]
    Name              tail
    Path              /var/log/containers/*.log
    Parser            json
    Tag               kube.*
    Refresh_Interval  5
    
    [OUTPUT]
    Name            es
    Match           kube.*
    Host            elasticsearch.logging.svc.cluster.local
    Port            9200
    HTTP_User       elastic
    HTTP_Passwd     ${ELASTIC_PASSWORD}
```

**Что делал:**
- Prometheus для метрик (CPU, Memory, Request latency)
- ELK (Elasticsearch, Logstash, Kibana) для логов
- Alerts через AlertManager
- Custom metrics для business logic

### 6. Ingress и Load Balancing

```yaml
# NGINX Ingress Controller
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: api-ingress
  annotations:
    cert-manager.io/cluster-issuer: "letsencrypt-prod"
    nginx.ingress.kubernetes.io/rate-limit: "100"
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
spec:
  ingressClassName: nginx
  tls:
  - hosts:
    - api.example.com
    secretName: api-tls
  rules:
  - host: api.example.com
    http:
      paths:
      - path: /users
        pathType: Prefix
        backend:
          service:
            name: user-service
            port:
              number: 80
      - path: /orders
        pathType: Prefix
        backend:
          service:
            name: order-service
            port:
              number: 80
```

**Что делал:**
- NGINX Ingress для маршрутизации
- cert-manager для SSL сертификатов
- Rate limiting
- A/B testing через weighted routing

### 7. StatefulSets для БД

```yaml
# PostgreSQL StatefulSet
apiVersion: v1
kind: ConfigMap
metadata:
  name: postgres-config
data:
  postgresql.conf: |
    shared_buffers = 256MB
    effective_cache_size = 1GB
    max_connections = 200
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: postgres
spec:
  serviceName: postgres
  replicas: 1
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
      - name: postgres
        image: postgres:13
        ports:
        - containerPort: 5432
        env:
        - name: POSTGRES_DB
          value: mydb
        - name: POSTGRES_PASSWORD
          valueFrom:
            secretKeyRef:
              name: postgres-secret
              key: password
        volumeMounts:
        - name: postgres-storage
          mountPath: /var/lib/postgresql/data
        - name: postgres-config
          mountPath: /etc/postgresql
      volumes:
      - name: postgres-config
        configMap:
          name: postgres-config
  volumeClaimTemplates:
  - metadata:
      name: postgres-storage
    spec:
      accessModes: ["ReadWriteOnce"]
      storageClassName: fast-ssd
      resources:
        requests:
          storage: 50Gi
```

**Что делал:**
- Persistent Volumes для данных
- Database replication
- Backup automation
- Recovery procedures

### 8. Основные вызовы и решения

```python
challenges = {
    "Network Policy": {
        "Проблема": "Контроль трафика между сервисами",
        "Решение": "NetworkPolicy для микро-сегментации",
    },
    "Resource Limits": {
        "Проблема": "Один pod убивает весь cluster",
        "Решение": "Requests/Limits для каждого контейнера",
    },
    "Secret Management": {
        "Проблема": "Credentials в коде",
        "Решение": "Sealed Secrets или HashiCorp Vault",
    },
    "Multi-tenancy": {
        "Проблема": "Изоляция тенантов",
        "Решение": "RBAC, Network Policies, Resource Quotas",
    },
    "Storage": {
        "Проблема": "Персистентность данных",
        "Решение": "StorageClass + PVC, backup strategy",
    },
}
```

### 9. Инструменты, которые я использовал

```bash
# Helm для управления чартами
helm repo add stable https://charts.helm.sh/stable
helm install my-release stable/postgresql

# kubectl для управления
kubectl apply -f deployment.yaml
kubectl logs -f pod-name
kubectl exec -it pod-name -- bash

# Kustomize для вариативности
kustomize build overlays/prod | kubectl apply -f -

# ArgoCD для GitOps
helm repo add argo https://argoproj.github.io/argo-helm

# kubecost для мониторинга расходов
```

### Основные выводы из опыта

```python
learnings = [
    "Kubernetes это инструмент, а не silver bullet",
    "Начни с малого: используй GKE/EKS, не собирай сам",
    "Resource requests/limits критичны, не забудь",
    "Monitoring и logging с первого дня",
    "Разделяй окружения (dev, staging, prod) через namespaces",
    "RBAC security важнее чем ты думаешь",
    "Network policies спасают при проблемах",
    "Документируй, иначе через 3 месяца забудешь",
]
```

**Вывод:** За годы я развёртывал в Kubernetes всё: от простых веб-приложений до сложных микросервисных систем с мониторингом, масштабированием и failover механизмами. Kubernetes мощный инструмент для production, но требует глубокого понимания networking, storage и resource management.

Что запускал в Kubernetes?

Комментарии (1)

Опыт работы с Kubernetes

Краткий ответ

1. Микросервисная архитектура

2. Django приложения

3. Celery (асинхронные задачи)

4. Batch Processing (Apache Spark)

5. Мониторинг и логирование

6. Ingress и Load Balancing

7. StatefulSets для БД

8. Основные вызовы и решения

9. Инструменты, которые я использовал

Основные выводы из опыта