Login Get started

Kubernetes 101 workshop - complete hands-on

Kubesimplify・157 minutes read

The workshop "Kubernetes 101" covers the basics of Kubernetes, explaining its importance for managing containers at scale and providing essential features like auto-scaling, scheduling, and monitoring. Key topics include Kubernetes architecture, resource management, deployment strategies, networking, and practical demonstrations, emphasizing the significance of probes, resource requests, and StatefulSets for different types of applications.

Insights

Kubernetes, an open-source system for automating deployment and management of containerized applications, is essential for software developers, DevOps engineers, and support engineers, designed for massive scale and offering features like auto-scaling, scheduling, and self-healing.
The workshop covers Kubernetes basics, including pods, deployments, networking, authentication, secrets, and local setup, emphasizing the importance of Kubernetes for managing containers at scale and eliminating manual tasks.
Kubernetes architecture involves the API server, controller manager, scheduler, and kubelet to execute user commands, with commands stored in etcd for cluster state, requiring three etcd nodes for high availability and leader election.
YAML files in Kubernetes use specific syntax like dashes for lists, pipes for multi-line strings, and placeholders for environment variables, crucial for defining objects, metadata, and specifications in Kubernetes resources.
Kubernetes namespaces isolate environments for different teams, aiding in resource organization, team isolation, and policy enforcement, with commands like `kubectl create namespace` and `kubectl delete namespace` for management.

Get key ideas from YouTube videos. It’s free

Recent questions

What is Kubernetes?
Kubernetes is an open-source system for automating deployment, scaling, and management of containerized applications.
How does Kubernetes work?
Kubernetes manages container scheduling, auto-healing, and operations at scale, using tools like kubectl for cluster interaction.
Why is Kubernetes important?
Kubernetes offers flexibility, auto-scaling, monitoring, and production readiness, eliminating manual tasks and custom scripts.
What are the key components of Kubernetes?
Kubernetes architecture includes API server, scheduler, controller manager, kubelet, and etcd for cluster state management.
How can I start learning Kubernetes?
To begin learning Kubernetes, explore workshops, online tutorials, and practical examples to understand its concepts and applications.

Related videos

Summary

00:00

"Kubernetes 101 Workshop with Sam Patrick"

The workshop is titled "Kubernetes 101" and is hosted by Sam Patrick, a CNCF ambassador and director at Civo, a cloud hosting company with a managed Kubernetes offering.
Participants are encouraged to share the workshop link on social media for maximum reach and are advised to stay for the duration to learn about Kubernetes.
The chat is moderated by Cube Simplify ambassadors who also handle Q&A, and participants are directed to join the Cube Simplify Discord for better interaction and support.
The workshop covers Kubernetes basics, including pods, deployments, stateful sets, networking, services, authentication, authorization, admission, config maps, secrets, and potentially local and kube admin setup.
Kubernetes, also known as K8s, is an open-source orchestration system for automating deployment, scaling, and management of containerized applications, hosted under CNCF.
Kubernetes was developed by Google based on their internal systems Borg and Omega, launched in 2014, and is essential for various roles like software developers, DevOps engineers, and support engineers.
Kubernetes is designed for massive scale, running anywhere from Raspberry Pi's to cloud environments, orchestrating containers and providing features like auto-scaling, scheduling, monitoring, and self-healing.
The workshop explains why Kubernetes is necessary for managing containers at scale, offering flexibility, auto-scaling, scheduling, monitoring, and production readiness, eliminating manual tasks and custom scripts.
Kubernetes acts as an orchestration system, managing container scheduling, auto-healing, and other operations at scale, using tools like kubectl for interaction with the cluster.
The workshop delves into Kubernetes architecture, where commands from users like running a container are sent to the API server, which then communicates with the controller manager, scheduler, and kubelet to execute the desired actions.

18:06

"Kubernetes Architecture: Control, Nodes, and Networking"

Two virtual machines created, one with a control plane and the other as a worker node for running containers.
Control plane manages the cluster with components like API server, scheduler, controller manager, etc.
API server is the main brain of Kubernetes, handling authentication, authorization, and admission of requests.
Requests are saved to etcd, a key-value database for the cluster's state.
For high availability, three etcd nodes are needed for consensus and leader election using the raft algorithm.
Scheduler finds the best node to run a pod based on resource requests and node capacity.
Cubelet on worker nodes communicates with API server to run pods using the container runtime interface (CRI).
Cube proxy maintains network rules on nodes for pod communication within and outside the cluster.
Controller manager controls different Kubernetes objects like replica sets, deployments, and stateful sets.
Cloud controller manager connects Kubernetes to the cloud for actions like creating load balancers.

35:18

"YAML Basics and Kubernetes Configuration Essentials"

To define a list in YAML, use a list of items with a dash for each list item, ensuring proper indentation with two spaces.
List items in YAML are represented by a dash, and indentation is crucial to show the relationship between objects and attributes.
To write multiple sentences or commands in a YAML file, use a pipe symbol for a multi-line string.
The CA certificate file in Kubernetes requires a multi-line string, indicated by appending a pipe symbol.
When writing a shell script inside a pod in a YAML file, use a pipe symbol to denote a multi-line string.
In YAML, placeholders like "$image" and "$deploy" are used for environment variables, and multiple objects can be separated by three colons.
Common elements in a Kubernetes YAML file include "apiVersion," "kind," "metadata," and "spec."
The "group version resource" (GVR) in Kubernetes refers to the collection of kinds within a group, with versions like alpha, beta, and stable.
The metadata section in a YAML file typically includes annotations and labels, with labels and name being essential components.
The spec section in a YAML file specifies the desired characteristics of the object being created, such as the container image and name.

54:38

"Kubernetes Namespaces: Isolation, Quotas, and Policies"

Namespaces in Kubernetes isolate environments for different teams, ensuring each team has its own quota, control, and policies.
Running applications in separate namespaces prevents interference between teams' applications.
Namespace segregation allows for different policies, quotas, and network restrictions for each team.
Namespace usage extends beyond team isolation to organizing resources like monitoring, databases, and service mesh components.
Deploying resources in distinct namespaces aids in monitoring, managing, and segregating components effectively.
Creating namespaces can be done imperatively or declaratively, with commands like `kubectl create namespace` or `kubectl create namespace --dry-run`.
Deleting namespaces and their resources is possible with `kubectl delete namespace`.
Switching contexts to view resources in different namespaces is achievable with commands like `kubectl get pods` and `kubectl get pods -n dev`.
Labels in Kubernetes add meaning to objects, aiding in selection and traffic routing based on key-value pairs.
Selectors in Kubernetes, like match labels and match expressions, help in selecting objects based on labels for traffic routing and deployment management.

01:14:36

Understanding Kubernetes Pod Lifecycle and Management

Cubelet initiates pulling the image and starting the creator, followed by starting the container, detailing all events and toleration.
Quality of service class is mentioned, but not elaborated due to being beyond Kubernetes 101 scope.
Mounts include a service account token for interacting with the Kubernetes API server within the pod.
Container information encompasses container ID, image, SHA, host port state, restart count, IP, and annotations.
Annotations are added as part of the mutation process by Calico, a CNI project.
Descriptions of the pod include name, namespace, node, and labels.
Viewing application logs is done using "kubectl logs -f" to follow the pod's logs.
Additional actions involve "kubectl get pods" to delete a pod, "kubectl exec" to access a pod's shell, and "kubectl get pods -o wide" for a wider view of pod information.
Deleting a pod triggers a 30-second termination grace period to complete ongoing requests.
The pod lifecycle progresses through pending, container creating, running, error, and succeeded stages, based on scheduler and container actions.

01:33:40

Creating and Configuring Multi-Container Pods with Probes

The initiation process involves creating a demo pod with an init container that must complete before the main container starts.
Services need to be created for the demo to function correctly, ensuring error validation is correct.
After creating the services, checking the pod status with "cube ctl get parts" shows the pod starting.
Moving on to a multi-container setup, a pod with both Nginx and Alpine containers is created, sharing data between them.
Applying the multi-container pod configuration and checking with "cube ctl get pods" confirms both containers are running.
To view logs of the multi-container pod, "cube ctl describe pod" shows the containers present, and logs can be accessed using specific commands.
Checking the HTML file content within the containers can be done using "cube ctl exec" with a curl command.
Understanding the importance of container probes, readiness, startup, and liveness probes are explained for traffic handling and deadlock prevention.
Probes can be configured with specific checks, timeouts, and success/failure criteria to ensure pod health.
A practical workshop demonstrates applying probes to a pod, testing liveness with different paths and TCP socket checks, showcasing the importance of probe configurations.

01:54:39

Efficient Resource Management in Kubernetes

The metric server is successfully running at one out of one.
Understanding resource requests and limits is crucial for efficient resource utilization in Kubernetes.
Resources in Kubernetes are defined as limits and requests, with CPU and memory specifications.
Requests signify the minimum resources needed for a pod, while limits set a maximum threshold.
Demonstrating resource management with `kubectl create -f rr` command.
Throttling occurs when resource usage exceeds the specified limits, as shown with `kubectl top pods`.
Creating a pod with resource requests exceeding available capacity results in a pending state due to insufficient resources.
The scheduler intelligently allocates pods based on available resources, preventing overloading nodes.
Kubernetes deployments ensure application availability by managing pod replicas.
Updating a deployment triggers the creation of new pods while maintaining service continuity.

02:25:54

Managing Kubernetes Deployments and StatefulSets Effectively

Kubernetes applications have a grace period called the termination grace period, allowing ongoing requests to complete before new pods are created.
The rolling update strategy ensures application availability during image changes, with default settings of 25% max unavailable and 25% max surge.
The min ready seconds setting determines the time a new pod must be ready before receiving traffic.
Deployment creation involves using commands like `kubectl create deploy` and `kubectl get deploy` to manage pods and replica sets.
Scaling a deployment can be done using `kubectl scale deploy` or editing the deployment directly with `kubectl edit deploy`.
Changing the image of a deployment involves updating the image with commands like `kubectl set image deploy` and monitoring the rollout status with `kubectl rollout status`.
Rollbacks can be initiated using `kubectl rollout undo` to revert to a previous image version.
Stateful applications like databases require a different approach using StatefulSets to maintain data consistency and predictable pod names.
StatefulSets ensure data consistency by creating pods with predictable names and using headless services for write operations.
Local path provisioners can be used to create persistent volumes for StatefulSets, ensuring data persistence and replication mechanisms for databases.

02:45:26

"Stateful set creation and networking in Kubernetes"

Stateful set creation involves binding both status and parts within a container, ensuring a perfect stateful set operation.
Understanding the components' names is crucial, including pods, PVC, and PV creation flow.
Executing into a pod allows for volume interaction, aiding in replication mechanisms.
Accessing services through DNS resolution requires passing the pod name, service name, namespace, and svc cluster local.
Utilizing predictable DNS enables writing into pods for replication purposes.
Checking the resolve.conf file confirms the default svc cluster local setup.
Networking exploration delves into pod creation, network namespaces, and pause containers' roles.
The pause container serves to hold the network namespace, crucial for networking functionality.
Inter-node pod communication involves traffic routing through eth0, ve pairs, and root namespaces.
Services in Kubernetes facilitate traffic routing, ensuring end-user access to applications despite pod IP changes.

03:07:31

"Kubernetes Services: Essential Details and Types"

A virtual IP is essential for maintaining constant service IDs and load balancing in applications with multiple replicas.
Cluster IP service is the default service type in Kubernetes, automatically created if no specific type is specified.
The API version, kind, metadata, and ports are crucial details in defining a service in Kubernetes.
Target ports are significant for directing requests to specific containers in a service.
Pods are created using commands like `kubectl run nginx --image=nginx` and exposed with `kubectl expose pod nginx --port=80`.
Endpoints in Kubernetes automatically update with new pod IPs, ensuring traffic is directed to the latest pods.
Services select pods based on labels, like `run=nginx`, for traffic distribution.
Multiport services require naming ports for clarity and organization.
NodePort services provide external access to cluster IPs, while LoadBalancer services are cloud-specific for external IP access.
Headless services are used for stateful sets, allowing direct communication with pods using DNS.

03:31:58

Essential Kubernetes Management and Setup Guide

Viewing resources, service account permissions, and commands like `kubectl` are essential in Kubernetes management.
Node.js and Python applications require property files, environment variables, usernames, and passwords for Kubernetes usage.
Config maps and secrets in Kubernetes store application properties and sensitive data like passwords.
Config maps contain key-value pairs for application properties, while secrets store sensitive data.
Within a pod, environment variables are set using config maps, specifying the key for the value.
Config maps can be volume-mounted in a pod to access multiple files, each with distinct content.
A practical example involves creating config maps and secrets, then using them within a pod.
Local Kubernetes setup options include Docker Desktop, Rancher Desktop, and Minikube.
Detailed steps for setting up Kubernetes on Ubuntu involve installing components, disabling swap memory, and configuring Containerd.
The Kubernetes setup process includes bootstrapping the cluster, setting pod network CIDR, and running the first command to deploy an Nginx pod.

03:54:26

"Mini cube workshop launches Kubernetes video series"

Ensure you have a mini cube set up for the workshop to launch clusters; upcoming video series by Cube Simplify Ambassadors on Kubernetes from scratch will be shared, notes will be available for download in the repository, share reviews on Twitter, and stay connected for more learning opportunities.

Try it yourself — It’s free.