Speed learn Kubernetes coming from AWS

Introduction

Imagine trading your well-known AWS console/CLI for a terminal where YAML files rule your destiny – welcome to Kubernetes!

What is Kubernetes

In a gist, Kubernetes (or k8s) is just a fancy docker-compose. It allows you to spin up, orchestrate and run multiple "containers" or applications on a machine. A machine can be a local computer or a cloud provider as well like AWS and Azure.

Migrating to K8s

Regardless of where you're coming from, migrating to Kubernetes is not an easy task (except for that TodoApp you're still hosting for some reason ☺︎).

Being 100% sure you can invest tremendous effort in that migration is key, the last thing you would want to do is maintain 2 orchestrating systems forever and never reach the end of the tunnel where the benefits lies!

Disclaimer out of the way, this migration can be highly beneficial, addressing a multitude of operational challenges without reinventing the wheel:

• Fast, Reliable/Standardized deployment processes for systems (Canary, Blue/Green, Rolling updates...).
• Security and User/Resource Access. What team/role can access what? Elevating access in case of incidents? Enforcing certain practices...
• Cost monitoring and reduction. Monitor resource utilization, control costs and enforce tagging/ cost monitoring standards.
• Portability and Flexibility. Easily move workloads between cloud environments or even run them on-premises.
• Ephemeral Environments and Automation. Spin up a new isolated test environments in a breeze.
• Local development Parity. Spin up your entire system locally exactly the same way you'll be doing it on production.

K8s on Cloud

Actual Examples

• Centralized Telemetry (OpenTelemetry Agent + Gateway setup)
• Spinning up a chaos testing infrastructure, running recurrent load/spike tests.
• Enforcing tagging, resource based rules for best practices in a given org.
• Readiness and healthiness of a given system

Resource and State Management

Declarative State Reconciliation

A bit similar to ECS Fargate/Terraform, Kubernetes relies on a declarative configuration in YAML, indicating the targeted state that you would want your system to have.

Kubernetes constantly monitors your cluster vs the desired state, and automatically adjust to make sure it always matches the declared configuration.

All this configuration is stored in YAML, and most changes are automatically versioned and applied independently using kubectl apply.

E.g is defining how many instances of Service A would you want to have, if one instance crashes, Kubernetes will automatically spin up a new instance.

This is similar in most managed services like AWS Fargate/ECS. This eliminates the risk of manual errors often encountered with imperative commands.

Terminology and AWS mind-mapping

Transitioning from AWS to Kubernetes can be smoother when you map familiar concepts to their Kubernetes counterparts.

Picked AWS out of popularity, but happy to include more detailed/expanded versions.

Context

A Kubernetes Context is very similar to an AWS Account Profile. Each context allows you to see/manipulate different set of resources (Cluster/Namespace).

Example would be different clusters between staging and production environments. Similarly to aws configure, set-context would be called to move around.

Cluster

A cluster is a collection of Worker machines called Nodes. Along with the Nodes, Kubernetes hosts what's called Control Plane, components and modules that are used by K8s to manage the Nodes/Pods.

Node

A Kubernetes Node is a physical or virtual machine. Nodes are managed by the Control Plane on the Cluster.

Namespace

Just as namespaces in programming help group related classes and functions, Kubernetes Namespaces logically separate clusters into different environments or teams. This is especially useful in multi environments/team setups.

Pod → AWS Task Definition

A Kubernetes Pod is the smallest deployable unit. A Pod can host one or more containers. This is very similar to an AWS Task Definition on ECS, which hosts instructions and runtime specs to auto deploy AWS Tasks.

Deployment

Just like AWS ECS, Kubernetes manages the pods deployments. How is the Pod rolled out and scaled in/out etc... Kubernetes Deployments are linked to strategies for rolling updates, rollbacks, and ensures that the desired number of replicas is running.

Replica-Set

Replica-Sets are very similar to AWS Auto Scaling Groups which are part of ECS. A Replica-Set ensures that a specified number of identical Pods are running at any given time.

Service

In Kubernetes, a Service abstracts the networking layer to provide a stable endpoint for a set of Pods, mainly used for load balancing and service discovery.

In AWS, you might use an Application Load Balancer to expose your application. Note that Kubernetes will connect/provision an actual AWS ALB and use that while abstracting its existence from the Pod point of view.

Probes

Similar to health checks in AWS (e.g., ALB Health Checks to Target Groups), Kubernetes uses probes to determine the state of a container:

• Liveness Probes: Verify if a container is still running. If a probe fails, Kubernetes will restart the container.
• Readiness Probes: Check if a container is ready to accept traffic. This ensures that only healthy pods receive requests.
• Startup Probes: Allow for slow-starting applications by delaying the liveness and readiness checks until the app has had time to fully initialize.

This area is a bit more advanced and thought out compared to AWS, the "Readiness" implementation on ECS can be very manual and blurry.

Helm

Helm is the package manager for Kubernetes. It simplifies the deployment of complex applications using "charts", which are like AWS CloudFormation templates or Terraform modules.

Helm charts package together all necessary Kubernetes resources and configuration, streamlining/centralizing resource definitions and deployment.

What's next

This write up should give you the basics of Kubernetes to get you started. There's few examples that you can now use and understand.

Happy deployments!