An in depth overview of Kubernetes and it's various components.
NOTE: This is a fixed version of a previous presentation (a draft was uploaded with some errors)
Kubernetes: A Short Introduction (2019)Megan O'Keefe
Kubernetes is an open-source system for automating deployment, scaling, and management of containerized applications. It groups containers that make up an application into logical units for easy management and discovery called pods. Kubernetes can manage pods across a cluster of machines, providing scheduling, deployment, scaling, load balancing, volume mounting and networking. It is widely used by companies like Google, CERN and in large projects like processing images and analyzing particle interactions. Kubernetes is portable, can span multiple cloud providers, and continues growing to support new workloads and use cases.
Kubernetes is an open source container orchestration system that automates the deployment, maintenance, and scaling of containerized applications. It groups related containers into logical units called pods and handles scheduling pods onto nodes in a compute cluster while ensuring their desired state is maintained. Kubernetes uses concepts like labels and pods to organize containers that make up an application for easy management and discovery.
Kubernetes for Beginners: An Introductory GuideBytemark
Kubernetes is an open-source tool for managing containerized workloads and services. It allows for deploying, maintaining, and scaling applications across clusters of servers. Kubernetes operates at the container level to automate tasks like deployment, availability, and load balancing. It uses a master-slave architecture with a master node controlling multiple worker nodes that host application pods, which are groups of containers that share resources. Kubernetes provides benefits like self-healing, high availability, simplified maintenance, and automatic scaling of containerized applications.
K8s in 3h - Kubernetes Fundamentals TrainingPiotr Perzyna
Kubernetes (K8s) is an open-source system for automating deployment, scaling, and management of containerized applications. This training helps you understand key concepts within 3 hours.
Helm is a package manager for Kubernetes that allows for easy installation, upgrade, and management of Kubernetes applications. It provides repeatability, reliability, and simplifies deploying applications across multiple Kubernetes environments. Helm originated from an internal hackathon at Deis and was jointly developed by Google and Deis. It is now maintained by the Cloud Native Computing Foundation. Helm consists of a client that interacts with the Tiller server running inside the Kubernetes cluster to manage application lifecycles using charts, which are packages containing Kubernetes resource definitions.
In this session, we will discuss the architecture of a Kubernetes cluster. we will go through all the master and worker components of a kubernetes cluster. We will also discuss the basic terminology of Kubernetes cluster such as Pods, Deployments, Service etc. We will also cover networking inside Kuberneets. In the end, we will discuss options available for the setup of a Kubernetes cluster.
This document discusses microservices and containers, and how Kubernetes can be used for container orchestration. It begins with an overview of microservices and the benefits of breaking monolithic applications into independent microservices. It then discusses how containers can be used to package and deploy microservices, and introduces Docker as a container platform. Finally, it explains that as container usage grows, an orchestrator like Kubernetes is needed to manage multiple containers and microservices, and provides a high-level overview of Kubernetes' architecture and capabilities for scheduling, self-healing, scaling, and other management of containerized applications.
A basic introductory slide set on Kubernetes: What does Kubernetes do, what does Kubernetes not do, which terms are used (Containers, Pods, Services, Replica Sets, Deployments, etc...) and how basic interaction with a Kubernetes cluster is done.
Kubernetes is an open-source system for automating deployment, scaling, and management of containerized applications. It groups containers that make up an application into logical units for easy management and discovery called pods. Kubernetes masters manage the cluster and make scheduling decisions while nodes run the pods and containers. It uses labels and selectors to identify and group related application objects together. Services provide a single endpoint for pods, while deployments help manage replicated applications. Kubernetes provides mechanisms for storage, configuration, networking, security and other functionality to help run distributed systems reliably at scale.
Docker allows building portable software that can run anywhere by packaging an application and its dependencies in a standardized unit called a container. Kubernetes is an open-source system for automating deployment, scaling, and management of containerized applications. It groups containers that make up an application into logical units for easy management and discovery. Kubernetes can replicate containers, provide load balancing, coordinate updates between containers, and ensure availability. Defining applications as Kubernetes resources allows them to be deployed and updated easily across a cluster.
Kubernetes is an open-source system for automating deployment, scaling, and management of containerized applications. It was originally developed by Google based on years of experience running production workloads at scale. Kubernetes groups containers into logical units called pods and handles tasks like scheduling, health checking, scaling and rollbacks. The main components include a master node that manages the cluster and worker nodes that run application containers scheduled by the master.
Kubernetes is an open-source system for automating deployment, scaling, and management of containerized applications. It groups containers that make up an application into logical units for easy management and discovery called pods. Its main components include a master node that manages the cluster and worker nodes that run the applications. It uses labels to identify pods and services and selectors to group related pods. Common concepts include deployments for updating apps, services for network access, persistent volumes for storage, and roles/bindings for access control. The deployment process involves the API server, controllers, scheduler and kubelet to reconcile the desired state and place pods on nodes from images while providing discovery and load balancing.
If you’re working with just a few containers, managing them isn't too complicated. But what if you have hundreds or thousands? Think about having to handle multiple upgrades for each container, keeping track of container and node state, available resources, and more. That’s where Kubernetes comes in. Kubernetes is an open source container management platform that helps you run containers at scale. This talk will cover Kubernetes components and show how to run applications on it.
Soft Introduction to Google's framework for taming containers in the cloud. For devs and architects that they just enter the world of cloud, microservices and containers
This document provides an overview of Kubernetes, a container orchestration system. It begins with background on Docker containers and orchestration tools prior to Kubernetes. It then covers key Kubernetes concepts including pods, labels, replication controllers, and services. Pods are the basic deployable unit in Kubernetes, while replication controllers ensure a specified number of pods are running. Services provide discovery and load balancing for pods. The document demonstrates how Kubernetes can be used to scale, upgrade, and rollback deployments through replication controllers and services.
Kubernetes is an open-source system for automating deployment, scaling, and management of containerized applications. It coordinates activities across a cluster of machines by defining basic building blocks like pods (which contain containers), replication controllers (which ensure a specified number of pods are running), and services (which define logical groups of pods). Kubernetes provides tools for running applications locally on a single node as well as managing resources in the cluster, including creating, deleting, viewing, and updating resources from configuration files.
This document provides an overview of Kubernetes, an open-source system for automating deployment, scaling, and management of containerized applications. It describes basic Kubernetes components like pods, replication controllers, services, deployments, and replica sets. It explains how Kubernetes is used to group and schedule containers, maintain desired pod counts, update applications seamlessly with rolling updates, and more. The document also notes Kubernetes was inspired by Google's internal container systems and can manage applications across cloud and bare-metal environments.
Kubernetes & Google Kubernetes Engine (GKE)Akash Agrawal
This document discusses Kubernetes and Google Kubernetes Engine (GKE). It begins with an agenda that covers understanding Kubernetes, containers, and GKE. It then discusses traditional application deployment versus containerized deployment. It defines Kubernetes and containers, explaining how Kubernetes is a container orchestration system that handles scheduling, scaling, self-healing, and other functions. The document outlines Kubernetes concepts like clusters, pods, services, and controllers. It describes GKE as a managed Kubernetes service on Google Cloud that provides auto-scaling, integration with Google Cloud services, and other features.
Kubespray and Ansible can be used to automate the installation of Kubernetes in a production-ready environment. Kubespray provides tools to configure highly available Kubernetes clusters across multiple Linux distributions. Ansible is an IT automation tool that can deploy software and configure systems. The document then provides a 6 step guide for installing Kubernetes on Ubuntu using kubeadm, including installing Docker, kubeadm, kubelet and kubectl, disabling swap, configuring system parameters, initializing the cluster with kubeadm, and joining nodes. It also briefly explains Kubernetes architecture including the master node, worker nodes, addons, CNI, CRI, CSI and key concepts like pods, deployments, networking,
Kubernetes is an open-source system for managing containerized applications across multiple hosts. It includes key components like Pods, Services, ReplicationControllers, and a master node for managing the cluster. The master maintains state using etcd and schedules containers on worker nodes, while nodes run the kubelet daemon to manage Pods and their containers. Kubernetes handles tasks like replication, rollouts, and health checking through its API objects.
(Draft) Kubernetes - A Comprehensive OverviewBob Killen
Kubernetes is an open-source system for automating deployment, scaling, and management of containerized applications. It groups containers that make up an application into logical units for easy management and discovery called pods. Its main components include a master node that manages the cluster and worker nodes that run the applications. It uses labels to organize resources and selectors to group related objects. Common concepts include pods, services for discovery/load balancing, replica controllers for scaling, and namespaces for isolation. It provides mechanisms for configuration, storage, security, and networking out of the box to ensure containers can run reliably and be easily managed at scale.
Kubernetes is an open-source system for automating deployment, scaling, and management of containerized applications. It groups containers that make up an application into logical units for easy management and discovery called pods. Kubernetes masters manage pods and provide shared services through components like etcd (for shared storage) and controllers. Nodes run pods and agents like kubelet and kube-proxy. Kubernetes uses concepts like deployments, services, and labels to abstractly define applications and make them accessible. It provides tools for self-healing, scaling, and lifetime management of containerized applications.
This document provides an overview of Kubernetes, including its architecture, components, concepts, and configuration. It describes that Kubernetes is an open-source container orchestration system designed by Google to manage containerized applications across multiple hosts. The key components include the master nodes which run control plane components like the API server, scheduler, and controller manager, and worker nodes which run the kubelet and containers. It also explains concepts like pods, services, deployments, networking, storage, and role-based access control (RBAC).
This presentation covers how app deployment model evolved from bare metal servers to Kubernetes World.
In addition to theoretical information, you will find free KATACODA workshops url to perform practices to understand the details of the each topics.
This document provides an overview of Kubernetes concepts including:
- Kubernetes architecture with masters running control plane components like the API server, scheduler, and controller manager, and nodes running pods and node agents.
- Key Kubernetes objects like pods, services, deployments, statefulsets, jobs and cronjobs that define and manage workloads.
- Networking concepts like services for service discovery, and ingress for external access.
- Storage with volumes, persistentvolumes, persistentvolumeclaims and storageclasses.
- Configuration with configmaps and secrets.
- Authentication and authorization using roles, rolebindings and serviceaccounts.
It also discusses Kubernetes installation with minikube, and common networking and deployment
Kubernetes is an open-source tool for managing containerized applications across clusters of nodes. It provides capabilities for deployment, maintenance, and scaling of applications. The document discusses Kubernetes concepts like pods, deployments, services, namespaces and components like the API server, scheduler and kubelet. It also covers Kubernetes commands and configuration using objects like config maps, secrets, volumes and labels.
Kubernetes-introduction to kubernetes for beginers.pptxrathnavel194
Kubernetes is an open source tool that provides automation and management of containerized applications across a cluster of nodes. It handles tasks like scheduling, deployment, scaling, and healing of containers. The main components include a master node with controllers and an API server, and worker nodes running kubelet and kube-proxy. Core objects in Kubernetes include pods to group related containers, services for discovery and load balancing, and deployments to declaratively manage replicated applications.
Kubernetes Architecture with ComponentsAjeet Singh
This document provides an overview of Kubernetes architecture and components. It describes how to run a simple Kubernetes setup using a Docker container. The container launches all key Kubernetes components including the API server, scheduler, etcd and controller manager. Using kubectl, the document demonstrates deploying an nginx pod and exposing it as a service. This allows curling the nginx default page via the service IP to confirm the basic setup is functioning.
Kubernetes is an open-source container management platform. It has a master-node architecture with control plane components like the API server on the master and node components like kubelet and kube-proxy on nodes. Kubernetes uses pods as the basic building block, which can contain one or more containers. Services provide discovery and load balancing for pods. Deployments manage pods and replicasets and provide declarative updates. Key concepts include volumes for persistent storage, namespaces for tenant isolation, labels for object tagging, and selector matching.
This is the most basic presentation introducing to the concepts of kubernetes this presentation only solves the mundane purpose as a visual aid to the session
Visualpath provides top-quality Certified Kubernetes Security Specialist Training Worldwide led by real-time instructors. We offer daily recordings and presentations for reference. Enroll for a Free Demo. Call +91-9989971070.
Visit Blog: https://visualpathblogs.com/
WhatsApp: https://www.whatsapp.com/catalog/917032290546/
Visit: https://www.visualpath.in/DevOps-docker-kubernetes-training.html
A brief study on Kubernetes and its componentsRamit Surana
Kubernetes is an open source orchestration system for Docker containers. It handles scheduling onto nodes in a compute cluster and actively manages workloads to ensure that their state matches the users declared intentions. Using the concepts of "labels" and "pods", it groups the containers which make up an application into logical units for easy management and discovery.
Recent momentum around the evolution of Containers are gradually increase in last two years.Containers virtualize an OS and applications running in each container believe that they have full access to their very own copy of that OS. This is analogous to what VMs do when they virtualize at a lower level, the hardware. In the case of containers, it’s the OS that does the virtualization and maintains the illusion.
Recent past many software companies have quickly adopted container technologies, including Docker Containers, aware of the threat and advantage of the approach. For example, Linux companies have also jumped into the ground, seeing as this as an opportunity to grow the Linux market. Also Microsoft is going to add features to support containers and VMware have made efforts in integrating support for Docker into virtual machine technology.
Recent momentum around the evolution of Containers are gradually increase in last two years.Containers virtualize an OS and applications running in each container believe that they have full access to their very own copy of that OS. This is analogous to what VMs do when they virtualize at a lower level, the hardware. In the case of containers, it’s the OS that does the virtualization and maintains the illusion.
Recent past many software companies have quickly adopted container technologies, including Docker Containers, aware of the threat and advantage of the approach. For example, Linux companies have also jumped into the ground, seeing as this as an opportunity to grow the Linux market. Also Microsoft is going to add features to support containers and VMware have made efforts in integrating support for Docker into virtual machine technology.
These slides were used during a technical session for the Cloud-Native El Salvador community. It covers the basic Kubernetes components, some installers and main Kubernetes resources. For the demo, it was used the capabilites provided by the Horizontal Pod Autoscaler.
Recent momentum around the evolution of Containers are gradually increase in last two years.Containers virtualize an OS and applications running in each container believe that they have full access to their very own copy of that OS. This is analogous to what VMs do when they virtualize at a lower level, the hardware. In the case of containers, it’s the OS that does the virtualization and maintains the illusion.
In Apache Cassandra Lunch #41: Apache Cassandra Lunch #41: Cassandra on Kubernetes - Docker/Kubernetes/Helm Part 1, we discuss Cassandra on Kubernetes and give an introduction to Docker, Kubernetes, and Helm.
Accompanying Blog: https://blog.anant.us/apache-cassandra-lunch-41-cassandra-on-kubernetes-docker-kubernetes-helm-part-1/
Accompanying YouTube: https://youtu.be/-I8cKQO_Qr0
Sign Up For Our Newsletter: http://eepurl.com/grdMkn
Join Cassandra Lunch Weekly at 12 PM EST Every Wednesday: https://www.meetup.com/Cassandra-DataStax-DC/events/
Cassandra.Link:
https://cassandra.link/
Follow Us and Reach Us At:
Anant:
https://www.anant.us/
Awesome Cassandra:
https://github.com/Anant/awesome-cassandra
Cassandra.Lunch:
https://github.com/Anant/Cassandra.Lunch
Email:
solutions@anant.us
LinkedIn:
https://www.linkedin.com/company/anant/
Twitter:
https://twitter.com/anantcorp
Eventbrite:
https://www.eventbrite.com/o/anant-1072927283
Facebook:
https://www.facebook.com/AnantCorp/
Similar to Kubernetes - A Comprehensive Overview (20)
Tackling New Challenges in a Virtual Focused CommunityBob Killen
The pandemic has had many communities scrambling to find ways to capture, grow, and continue to strengthen the bonds of their community members. Virtual events, zoom burn out, and increased familial responsibilities are things that are impacting not only contributors but software communities as a whole. They do pose an opportunity - They can be made more accessible, there are less financial pressures for attendees, and they open up possibilities for others that might not be able to previously contribute to open source. In this talk, we’ll go over some of the successes and failures that we have encountered over the past year, share our experiences, and explore strategies to mitigate “virtual” fatigue. Attendees will learn the following things: - How to approach virtual events and activities, both as an organizer and an attendee - Set and manage expectations with themselves and others - Technical do’s and don’ts with virtual events.
KubeCon EU 2021
KubeCon EU 2021 Keynote: Shaping Kubernetes Community CultureBob Killen
In this talk, members of the Kubernetes Steering Committee and Kubernetes Code of Conduct Committee walk through what it takes to lead a community from a technical, cultural, and community perspective, and how that stewardship improves camaraderie, code quality and longevity. Get a peek under the hood of the two community groups chartered with defining, evolving, and sustaining the values of the project.
Intro to Kubernetes SIG Contributor ExperienceBob Killen
In this 30 minute session, we will explore the projects we have been working on with Contributor Experience and the future work we have on deck. We will provide an update to the following projects and have information on how to get involved.
The CNCF Research User Group aims to function as a focal point for discussing and advancing research computing using cloud native technologies. This includes identifying current practices, gaps, and initiatives to improve the research cloud computing ecosystem. Some initiatives include surveying research institutions using Kubernetes, creating a book on best practices for running research clusters and making research cloud native, and discussing topics like configuration management, GPU management, scalable JupyterHub, Kubeflow, workflows, and data operations.
A Peek Behind the Curtain: Managing the Kubernetes Contributor CommunityBob Killen
The Kubernetes community is a vibrant beacon in open source. It takes a village to enable a city of contributors doing what they do best. There are a lot of fun stories and lessons to be shared from helping out the community. One lesson is taken straight from the Kubernetes project itself: declarative config management. Most aspects of the community are managed using declarative configs. Adding a new SIG, GitHub org member, and even Slack channel, involves updating and PRing a change into one of the many Kubernetes repos. Adopting this methodology provides the community the means to self-manage itself. Join us as we journey through the many bits of community automation and weigh the merits of automating every aspect of our community.
SCALE 18x 2020
Academic research institutions are at a precipice. They have historically been constrained to supporting classic “job” style workloads. With the growth of new workflow practices such as streaming data, science gateways, and more “dynamic” research using lambda-like functions, they must now support a variety of workloads.
In this talk, Lindsey and Bob will discuss some difficulties faced by academic institutions and how Kubernetes offers an extensible solution to support the future of research. They will present a selection of projects currently benefiting from Kubernetes enabled tools, like Argo, Kubeflow, and kube-batch. These workflows will be demonstrated using specific examples from two large research institutions: Compute Canada, Canada’s national computation research consortium and the University of Michigan, one of the largest public Universities in the United States.
KubeCon EU 2019
Kubernetes has become the defacto standard as a platform for container orchestration. Its ease of extending and many integrations has paved the way for a wide variety of data science and research tooling to be built on top of it.
From all encompassing tools like Kubeflow that make it easy for researchers to build end-to-end Machine Learning pipelines to specific orchestration of analytics engines such as Spark; Kubernetes has made the deployment and management of these things easy. This presentation will showcase some of the larger research tools in the ecosystem and go into how Kubernetes has enabled this easy form of application management.
Slides used for Orchestructure May 2018 workshop.
Labs:
https://github.com/mrbobbytables/k8s-intro-tutorials
Event Information:
https://www.meetup.com/orchestructure/events/250189685/
Federated Kubernetes: As a Platform for Distributed Scientific ComputingBob Killen
A high level overview of Kubernetes Federation and the challenges encountered when building out a Platform for multi-institutional Research and Distributed Scientific Computing.
Pluggable Infrastructure with CI/CD and DockerBob Killen
The docker cluster ecosystem is still young, and highly modular. This presentation covers some of the challenges we faced deciding on what infrastructure to deploy, and a few tips and tricks in making both applications and infrastructure easily adaptable.
Tarun Gaur On Data Breaches and Privacy FearsTarun Gaur
Tarun Gaur On Data Breaches and Privacy Fears https://www.cbs19news.com/story/50764645/tarun-gaur-on-data-breaches-and-privacy-fears-navigating-the-minefield-of-modern-internet-safety
Jarren Duran Fuck EM T shirts Jarren Duran Fuck EM T shirtsexgf28
Jarren Duran Fuck EM T shirts
https://www.pinterest.com/youngtshirt/jarren-duran-fuck-em-t-shirts/
Happy to Pay Fine for Expletive shirt,Happy to Pay Fine for Expletive T shirts,Jarren Duran Fuck EM T shirts Grabs yours today. tag and share who loves it.
Book dating , international dating phgrathomaskurtha9
International dating programhttps: please register here and start to meet new people todayhttps://www.digistore24.com/redir/384521/godtim/.
get started. https://www.digistore24.com/redir/384521/godtim/
The advent of social media has revolutionized communication, transforming the way people connect, share, and interact globally. At the forefront of this digital revolution are visionary entrepreneurs who recognized the potential of the internet to foster social connections and create communities. This essay explores the founders of some of the most influential social media platforms, their journeys, and the lasting impact they have made on society.
Mark Zuckerberg, along with his college roommates Eduardo Saverin, Andrew McCollum, Dustin Moskovitz, and Chris Hughes, founded Facebook in 2004. Initially created as a social networking site for Harvard University students, Facebook rapidly expanded to other universities and eventually to the general public. Zuckerberg's vision was to create an online directory that connected people through their real-life social networks.
Twitter, founded in 2006 by Jack Dorsey, Biz Stone, and Evan Williams, brought a new dimension to social media with its microblogging platform. Dorsey envisioned a service that allowed users to share short, real-time updates, limited to 140 characters (now 280). This concise format encouraged rapid sharing of information and fostered a culture of brevity and immediacy.
Kevin Systrom and Mike Krieger co-founded Instagram in 2010, focusing on photo and video sharing. Systrom, who studied photography, wanted to create an app that made mobile photos look professional. The app's unique filters and easy-to-use interface quickly gained popularity, amassing over a million users within two months of its launch.
Instagram's emphasis on visual content has had a significant cultural impact. It has popularized the concept of influencers, giving rise to a new industry where individuals can monetize their popularity and reach. The platform has also revolutionized digital marketing, enabling brands to connect with consumers in more authentic and engaging ways. Acquired by Facebook in 2012, Instagram continues to be a dominant force in social media, shaping trends and cultural norms.
Reid Hoffman founded LinkedIn in 2002 with the goal of creating a professional networking platform. Unlike other social media sites focused on personal connections, LinkedIn was designed to connect professionals, facilitate job searches, and foster business relationships. The platform allows users to create professional profiles, network with colleagues, and share industry insights.
LinkedIn has become an indispensable tool for job seekers, recruiters, and businesses. It has transformed the job market by making it easier to find and connect with potential employers and employees. LinkedIn's influence extends beyond job searches; it has become a hub for professional development, thought leadership, and industry news. Hoffman's vision has significantly impacted how professionals manage their careers and build their networks.
Jan Koum and Brian Acton co-founded WhatsApp in 2009, aiming to create a simple, reliable..
4. Intro - Who am I?
Bob Killen / rkillen@umich.edu
Twitter / Github: @mrbobbytables
Senior Research Cloud Administrator @ ARC-TS
http://arc-ts.umich.edu
5. Intro - What is Kubernetes?
Kubernetes or K8s was a project spun out of Google as a open source
next-gen container scheduler designed with the lessons learned from
developing and managing Borg and Omega.
Kubernetes was designed from the ground-up as a loosely coupled collection
of components centered around deploying, maintaining, and scaling
applications.
6. Intro - What Does Kubernetes do?
Kubernetes is the linux kernel of distributed systems.
It abstracts away the underlying hardware of the nodes and provides a
uniform interface for applications to be both deployed and consume the
shared pool of resources.
8. Architecture Overview
Masters - Acts as the primary control plane for Kubernetes. Masters are
responsible at a minimum for running the API Server, scheduler, and cluster
controller. They commonly also manage storing cluster state, cloud-provider
specific components and other cluster essential services.
Nodes - Are the ‘workers’ of a Kubernetes cluster. They run a minimal agent
that manages the node itself, and are tasked with executing workloads as
designated by the master.
12. kube-apiserver
The apiserver provides a forward facing REST interface into the kubernetes
control plane and datastore. All clients, including nodes, users and other
applications interact with kubernetes strictly through the API Server.
It is the true core of Kubernetes acting as the gatekeeper to the cluster by
handling authentication and authorization, request validation, mutation, and
admission control in addition to being the front-end to the backing datastore.
13. etcd
Etcd acts as the cluster datastore; providing a strong, consistent and highly
available key-value store used for persisting cluster state.
14. kube-controller-manager
The controller-manager is the primary daemon that manages all core
component control loops. It monitors the cluster state via the apiserver and
steers the cluster towards the desired state.
List of core controllers:
https://github.com/kubernetes/kubernetes/blob/master/cmd/kube-controller-manager/app/controllermanager.go#L332
15. cloud-controller-manager
The cloud-controller-manager is a daemon that provides cloud-provider
specific knowledge and integration capability into the core control loop of
Kubernetes. The controllers include Node, Route, Service, and add an
additional controller to handle PersistentVolumeLabels .
16. kube-scheduler
Kube-scheduler is a verbose policy-rich engine that evaluates workload
requirements and attempts to place it on a matching resource. These
requirements can include such things as general hardware reqs, affinity,
anti-affinity, and other custom resource requirements.
19. kubelet
Acts as the node agent responsible for managing pod lifecycle on its host.
Kubelet understands YAML container manifests that it can read from several
sources:
● File path
● HTTP Endpoint
● Etcd watch acting on any changes
● HTTP Server mode accepting container manifests over a simple API.
20. kube-proxy
Manages the network rules on each node and performs connection
forwarding or load balancing for Kubernetes cluster services.
Available Proxy Modes:
● Userspace
● iptables
● ipvs (alpha in 1.8)
21. Container Runtime
With respect to Kubernetes, A container runtime is a CRI (Container Runtime Interface)
compatible application that executes and manages containers.
● Containerd (docker)
● Cri-o
● Rkt
● Kata (formerly clear and hyper)
● Virtlet (VM CRI compatible runtime)
22. Additional Services
Kube-dns - Provides cluster wide DNS Services. Services are resolvable to
<service>.<namespace>.svc.cluster.local.
Heapster - Metrics Collector for kubernetes cluster, used by some resources
such as the Horizontal Pod Autoscaler. (required for kubedashboard metrics)
Kube-dashboard - A general purpose web based UI for kubernetes.
24. Networking - Fundamental Rules
1) All Pods can communicate with all other Pods without NAT
2) All nodes can communicate with all Pods (and vice-versa) without NAT.
3) The IP that a Pod sees itself as is the same IP that others see it as.
25. Networking - Fundamentals Applied
Containers in a pod exist within the same network namespace and share an
IP; allowing for intrapod communication over localhost.
Pods are given a cluster unique IP for the duration of its lifecycle, but the pods
themselves are fundamentally ephemeral.
Services are given a persistent cluster unique IP that spans the Pods lifecycle.
External Connectivity is generally handed by an integrated cloud provider or
other external entity (load balancer)
26. Networking - CNI
Networking within Kubernetes is plumbed via the Container Network
Interface (CNI), an interface between a container runtime and a network
implementation plugin.
Compatible CNI Network Plugins:
● Calico
● Cillium
● Contiv
● Contrail
● Flannel
● GCE
● kube-router
● Multus
● OpenVSwitch
● OVN
● Romana
● Weave
28. Kubernetes Concepts - Core
Cluster - A collection of hosts that aggregate their available resources including cpu, ram, disk,
and their devices into a usable pool.
Master - The master(s) represent a collection of components that make up the control plane of
Kubernetes. These components are responsible for all cluster decisions including both
scheduling and responding to cluster events.
Node - A single host, physical or virtual capable of running pods. A node is managed by the
master(s), and at a minimum runs both kubelet and kube-proxy to be considered part of the
cluster.
Namespace - A logical cluster or environment. Primary method of dividing a cluster or
scoping access.
29. Concepts - Core (cont.)
Label - Key-value pairs that are used to identify, describe and group together related sets of
objects. Labels have a strict syntax and available character set. *
Annotation - Key-value pairs that contain non-identifying information or metadata.
Annotations do not have the the syntax limitations as labels and can contain structured or
unstructured data.
Selector - Selectors use labels to filter or select objects. Both equality-based (=, ==, !=) or
simple key-value matching selectors are supported.
* https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#syntax-and-character-set
32. Concepts - Workloads
Pod - A pod is the smallest unit of work or management resource within Kubernetes. It is
comprised of one or more containers that share their storage, network, and context
(namespace, cgroups etc).
ReplicationController - Method of managing pod replicas and their lifecycle. Their
scheduling, scaling, and deletion.
ReplicaSet - Next Generation ReplicationController. Supports set-based selectors.
Deployment - A declarative method of managing stateless Pods and ReplicaSets. Provides
rollback functionality in addition to more granular update control mechanisms.
34. Concepts - Workloads (cont.)
StatefulSet - A controller tailored to managing Pods that must persist or maintain state. Pod
identity including hostname, network, and storage will be persisted.
DaemonSet - Ensures that all nodes matching certain criteria will run an instance of a
supplied Pod. Ideal for cluster wide services such as log forwarding, or health monitoring.
35. StatefulSet
● Attaches to ‘headeless service’ (not shown) nginx.
● Pods given unique ordinal names using the pattern
<statefulset name>-<ordinal index>.
● Creates independent persistent volumes based on
the ‘volumeClaimTemplates’.
36. DaemonSet
● Bypasses default scheduler
● Schedules a single instance on every host while
adhering to tolerances and taints.
37. Concepts - Workloads (cont.)
Job - The job controller ensures one or more pods are executed and successfully terminates. It
will do this until it satisfies the completion and/or parallelism condition.
CronJob - An extension of the Job Controller, it provides a method of executing jobs on a
cron-like schedule.
38. Jobs
● Number of pod executions can be controlled
via spec.completions
● Jobs can be parallelized using spec.parallelism
● Jobs and Pods are NOT automatically
cleaned up after a job has completed.
40. Concepts - Network
Service - Services provide a method of exposing and consuming L4 Pod network accessible
resources. They use label selectors to map groups of pods and ports to a cluster-unique virtual
IP.
Ingress - An ingress controller is the primary method of exposing a cluster service (usually
http) to the outside world. These are load balancers or routers that usually offer SSL
termination, name-based virtual hosting etc.
41. Service
● Acts as the unified method of accessing replicated pods.
● Four major Service Types:
○ CluterIP - Exposes service on a strictly cluster-internal IP (default)
○ NodePort - Service is exposed on each node’s IP on a statically
defined port.
○ LoadBalancer - Works in combination with a cloud provider to
expose a service outside the cluster on a static external IP.
○ ExternalName - used to references endpoints OUTSIDE the cluster
by providing a static internally referenced DNS name.
42. Ingress Controller
● Deployed as a pod to one or more hosts
● Ingress controllers are an external
controller with multiple options.
○ Nginx
○ HAproxy
○ Contour
○ Traefik
● Specific features and controller specific
configuration is passed through
annotations.
43. Concepts - Storage
Volume - Storage that is tied to the Pod Lifecycle, consumable by one or more
containers within the pod.
PersistentVolume - A PersistentVolume (PV) represents a storage resource. PVs are
commonly linked to a backing storage resource, NFS, GCEPersistentDisk, RBD etc. and are
provisioned ahead of time. Their lifecycle is handled independently from a pod.
PersistentVolumeClaim - A PersistentVolumeClaim (PVC) is a request for storage that
satisfies a set of requirements instead of mapping to a storage resource directly. Commonly
used with dynamically provisioned storage.
StorageClass - Storage classes are an abstraction on top of an external storage resource.
These will include a provisioner, provisioner configuration parameters as well as a PV
reclaimPolicy.
45. Persistent Volumes
● PVs are a cluster-wide resource
● Not directly consumable by a Pod
● PV Parameters:
○ Capacity
○ accessModes
■ ReadOnlyMany (ROX)
■ ReadWriteOnce (RWO)
■ ReadWriteMany (RWX)
○ persistentVolumeReclaimPolicy
■ Retain
■ Recycle
■ Delete
○ StorageClass
46. Persistent Volume Claims
● PVCs are scoped to namespaces
● Supports accessModes like PVs
● Uses resource request model similar to Pods
● Claims will consume storage from matching PVs
or StorageClasses based on storageClass and
selectors.
47. Storage Classes
● Uses an external system defined by the
provisioner to dynamically consume and
allocate storage.
● Storage Class Fields
○ Provisioner
○ Parameters
○ reclaimPolicy
48. Concepts - Configuration
ConfigMap - Externalized data stored within kubernetes that can be referenced as a
commandline argument, environment variable, or injected as a file into a volume mount. Ideal
for separating containerized application from configuration.
Secret - Functionally identical to ConfigMaps, but stored encoded as base64, and encrypted at
rest (if configured).
49. ConfigMaps and Secrets
● Can be used in Pod Config:
○ Injected as a file
○ Passed as an environment variable
○ Used as a container command (requires passing as env var)
50. Concepts - Auth and Identity (RBAC)
[Cluster]Role - Roles contain rules that act as a set of permissions that apply verbs like “get”,
“list”, “watch” etc over resources that are scoped to apiGroups. Roles are scoped to namespaces,
and ClusterRoles are applied cluster-wide.
[Cluster]RoleBinding - Grant the permissions as defined in a [Cluster]Role to one or more
“subjects” which can be a user, group, or service account.
ServiceAccount- ServiceAccounts provide a consumable identity for pods or external
services that interact with the cluster directly and are scoped to namespaces.
51. [Cluster]Role
● Permissions translate to url
path. With “” defaulting to core
group.
● Resources act as items the role
should be granted access to.
● Verbs are the actions the role
can perform on the referenced
resources.
52. [Cluster]RoleBinding
● Can reference multiple subjects
● Subjects can be of kind:
○ User
○ Group
○ ServiceAccount
● roleRef targets a single role only.
57. Kubectl
1) Kubectl performs client side
validation on manifest (linting).
2) Manifest is prepared and serialized
creating a JSON payload.
58. APIserver Request Loop
3) Kubectl authenticates to apiserver via x509, jwt,
http auth proxy, other plugins, or http-basic auth.
4) Authorization iterates over available AuthZ
sources: Node, ABAC, RBAC, or webhook.
5) AdmissionControl checks resource quotas,
other security related checks etc.
6) Request is stored in etcd.
7) Initializers are given opportunity to mutate request before the object is published.
8) Request is published on apiserver.
59. Deployment Controller
9) Deployment Controller is notified of the new
Deployment via callback.
10) Deployment Controller evaluates cluster state and
reconciles the desired vs current state and forms a
request for the new ReplicaSet.
11) apiserver request loop evaluates Deployment
Controller request.
12) ReplicaSet is published.
60. ReplicaSet Controller
13) ReplicaSet Controller is notified of the new ReplicaSet
via callback.
14) ReplicaSet Controller evaluates cluster state and
reconciles the desired vs current state and forms a request
for the desired amount of pods.
15) apiserver request loop evaluates ReplicaSet
Controller request.
16) Pods published, and enter ‘Pending’ phase.
62. Scheduler
17) Scheduler monitors published pods with no
‘NodeName’ assigned.
18) Applies scheduling rules and filters to find a
suitable node to host the Pod.
19) Scheduler creates a binding of Pod to Node and
POSTs to apiserver.
20) apiserver request loop evaluates POST request.
21) Pod status is updated with node binding and sets
status to ‘PodScheduled’.
63. Kubelet - PodSync
22) The kubelet daemon on every node polls the apiserver filtering
for pods matching its own ‘NodeName’; checking its current state
with the desired state published through the apiserver.
23) Kubelet will then move through a series of internal processes to
prepare the pod environment. This includes pulling secrets,
provisioning storage, applying AppArmor profiles and other various
scaffolding. During this period, it will asynchronously be POST’ing
the ‘PodStatus’ to the apiserver through the standard apiserver
request loop.
64. Pause and Plumbing
24) Kubelet then provisions a ‘pause’ container via the
CRI (Container Runtime Interface). The pause container
acts as the parent container for the Pod.
25) The network is plumbed to the Pod via the CNI
(Container Network Interface), creating a veth pair
attached to the pause container and to a container
bridge (cbr0).
26) IPAM handled by the CNI plugin assigns an IP to the
pause container.
65. Kublet - Create Containers
24) Kubelet pulls the container Images.
25) Kubelet first creates and starts any init containers.
26) Once the optional init containers complete, the
primary pod containers are started.
66. Pod Status
27) If there are any liveless/readiness probes, these are executed before the
PodStatus is updated.
28) If all complete successfully, PodStatus is set to ready and the container
has started successfully.
The Pod is Deployed!