This Kubernetes workshop aims to get you familiar, via experimentation, across the various components that make up the important aspects of Kubernetes, as a platform to host and manage the life-cycle of Microservices.
Kubernetes is an open-source platform for automating deployment, scaling, and operations of application containers across clusters of hosts, providing container-centric infrastructure
Kubernetes provides a container-centric management environnement. It orchestrates computing, networking, and storage infrastructure on behalf of user workloads. This provides much of the simplicity of Platform as a Service (PaaS) with the flexibility of Infrastructure as a Service (IaaS), and enables portability across infrastructure providers.
It is desirable that you are at least familiar with containerisation concepts, including Docker Engine and Docker Hub. If you feel like you would like to quickly get up to speed then, have a quick read of this reference.
The following diagram is a high-level representation of the Kubernetes cluster:
- Container: Normally this holds the “Application” that you want to deploy and run. Containers are decoupled and self-contained dependencies make them highly portable and scalable. Docker is the most common container runtime today.
- Pod: Encapsulates one or multiple containers, as a single unit of deployment. For example, this makes it easy to scale horizontally.
- Master Node(s): One or multiple virtual grouping of Controller components that make the Cluster’s Control Plane. It contains multiple types of Controllers for scheduling, detecting, and responding to cluster events e.g. starting up/terminating pods.
- Worker Node(s): One or multiple virtual grouping which has a main objective to run Pods. It is managed by the Master Controller components.
- kubelet: Is an agent that runs on each Worker Node in the cluster. It ensures that the containers described in Pod definitions are running and healthy as per the defined desired state.
- kube-proxy: Communicates back to what ? with the Host’s network rules and firewalls to enable service connections/ports exposure.
- kubectl: Is the command line interface to describe the cluster’s desired state, including what applications to run, how many replicas, network and disk resources, services, load balancers, etc. It talks directly to the API Server to the various Master Controllers.
- kube-API-server: Is a runtime service on the Master Node(s) that exposes the Kubernetes API and fronts end the Kubernetes control plane.
a component on the Master Node(s) that runs sub-controllers, such as:
- Node Controller: Monitors
Pods. Take actions when Pods go down.
- Replication Controller: Monitors and maintains the number of pods of every replication controller definition in the cluster.
- Endpoint Controller: Links services to pods
- Service Accounts and Token Controllers: Create default accounts and API access tokens for new namespaces.
- Node Controller: Monitors
- kube-Scheduler: Takes newly created Pods (Pod definitions) and based on different criteria assigns a Node for them to run on. These criteria can be based on: hardware and software policy constraints, affinity/anti-affinity specifications, data locality, etc.
- DNS: Is an embedded DNS Server that helps serve domain names for Kubernetes services and thus ease of services interoperability.
- etcd: Consistent and highly available key/value store of all Kubernetes cluster metadata.
Other technologies that we are using as part of this Hands-on Lab:
- Weave Scope: A real time monitoring dashboard that complements the Kubernetes dashboard UI. It allows you to correlate visually Application traffic. It also allows you to drill down into Containers within Pods running the actual workloads, scale in and out, gather console access, etc. See more
- Grafana/Prometheus: An open source platform for real time analytics and monitoring of workloads. See more
- Traefik: A modern reverse proxy and load balancer designed to dynamically front-end microservices running on Kubernetes. See more
- Istio (Service Mesh): An open source platform to connect, manage and secure microservices. It allows routing and in-depth telemetry and reporting. See more
- Zipkin: A distributed tracing system that dynamically builds traces from Application runtime requests and builds a logical transaction end-to-end that involves multiple microservices with the time spent on each span. It helps understand latency problems across distributed microservices architectures. See more
Sample Applications that we will use as part of this Hands-on Lab include:
Cheeses: A simple application made of 3 microservices. Each microservice corresponds to a type of cheese (cheddar, stilton, and wensleydale). When invoked (via API), it simply returns its name. This application is being used to demonstrate basic concepts on a clean architecture.
Socks shop: An e-commerce web application. It has a rich number of microservices, such as: front-end, catalogues, queues, orders, carts, DBs, payments, etc. This Application will be used to progressively demonstrate managing a real microservices-based application.
- Bookstore: This is a web-based application made of a handful of microservices, including Books, Books details, Book reviews, etc. This application will be used to demonstrate how to route, connect, manage, and secure microservices via a service mesh (Istio), real time monitoring (Grafana/Prometheus), real time traces and latencies (Zipkin) across each microservice call, etc.
I hope you found this blog useful. If you have any question or comment, feel free to contact me directly at https://www.linkedin.com/in/citurria/
Thanks for your time.