JDD 2017: Modern DevOps with Kubernetes (Michał Wroński)

## Overview Michał Wroński presents a hands-on exploration of Kubernetes as a modern DevOps solution, emphasizing that Kubernetes is a container orchestration engine designed to manage microservices at scale. The talk centers on three foundational principles for microservices: robust logging, monitoring, and health checks—without which infrastructure management becomes blind. Kubernetes enables automation, continuous delivery, and proper code isolation across services, making it invaluable for teams managing 10+ microservices.

## Key Architectural Concepts Kubernetes clusters consist of master nodes (the "brain" managing scheduling and desired state) and worker/agent nodes (where services are deployed). Access requires a secured context that proxies traffic properly. The fundamental deployment unit is a pod—a container or group of containers treated atomically, sharing network namespace, IP, ports, and volumes. Pods are ephemeral and managed by higher-level constructs; they should not be created manually in production.

## Core Technical Features **Deployments** provide declarative state management, specifying desired replicas, resource limits, and probe configurations. **Liveness probes** report whether deployment was successful, while **readiness probes** implement circuit-breaker logic—removing overloaded instances from load balancers during traffic spikes. **Replica Sets** (or replica controllers) maintain desired pod counts and enable rapid traffic switching during updates. **Services** provide load balancing and logical grouping of pods; they also enable service discovery via built-in DNS, allowing services to reference each other by name within the cluster. **ConfigMaps** and **Secrets** store key-value configuration separately from deployments, ensuring consistency across environments. **Daemon Sets** deploy a single pod instance on every node, useful for monitoring and logging agents. **StatefulSets** maintain startup order and state for services with dependencies. **Ingress** provides a single external entry point with routing rules, reducing security exposure from multiple service endpoints.

## Rolling Updates and Rollback Rolling updates occur without downtime or with minimal downtime. Kubernetes maintains old replica set versions in history, allowing rapid rollback via simple commands. Update strategy can be configured—for example, reducing instances by 50% during deployment on large services. The underlying mechanism is fast (milliseconds to nanoseconds) because it simply switches traffic between replica sets.

## Scaling and Monitoring Manual scaling uses simple commands to adjust replica counts. **Horizontal Pod Autoscaler (HPA)** reads metrics from Heapster, a central metrics aggregator that collects data from cAdvisor on each node. Monitoring integrations like Datadog use daemon sets to forward metrics and logs from nodes to aggregation services.

## Cloud Deployment Options **GCP** is the easiest entry point—Google invented Kubernetes, offers free master nodes, automatic scaling, and transparent cluster updates out-of-the-box. **Azure** provides Kubernetes via Container Service with single-command deployment, though auto-scaling support was still developing. **AWS** requires the Kops tool (more complex setup) but offers auto-scaling and version management. **Local development** uses Minikube instead of Vagrant or Docker Compose.

## When to Use Kubernetes Kubernetes is ideal for 10+ microservices, high resource utilization without idle time, and multi-team infrastructure sharing. For 2–5 microservices, manual scripts may suffice. Kubernetes enables multi-environment setups on single clusters via namespaces with resource quotas (e.g., development limited to 5% of cluster power, QA to 20%). **ECS vs. Kubernetes**: ECS handles only scaling; Kubernetes provides comprehensive orchestration including configuration management and service discovery. Kubernetes is cloud-agnostic, enabling migration and generic architectures.

## Key Benefits and Drawbacks **Advantages**: Eliminates shell scripts and configuration tools (Puppet, Chef); provides standardization through declarative manifests; ensures idempotent operations; transparent updates; built-in service discovery; integrated configuration management; supports local development. **Drawbacks**: Complexity increases with cluster size; Ingress creates additional hop in traffic path; requires understanding of multiple abstractions (pods, deployments, services, etc.).