Kubernetes, often abbreviated as K8s, is an open-source container orchestration platform for automating the deployment, scaling, and management of containerized applications. It was originally developed by Google and is now maintained by the Cloud Native Computing Foundation (CNCF). Kubernetes has become the de facto standard for managing containerized applications in modern cloud-native environments. Here are some key aspects and components of Kubernetes:
Key Concepts:
1. Containerization: Kubernetes is designed to work with containers, which are lightweight and consistent packaging units for applications and their dependencies. The most commonly used container runtime with Kubernetes is Docker.
2. Cluster: In Kubernetes, a cluster is a set of machines (nodes) that work together to run containerized applications. The cluster typically consists of a master node for control and multiple worker nodes for running containers.
3. Nodes: Worker nodes, often referred to as “minions,” are physical or virtual machines that run containerized applications. Each node has a container runtime (e.g., Docker), the Kubernetes agent (kubelet), and other supporting components.
4. Pods: Pods are the smallest deployable units in Kubernetes. A pod can contain one or more containers that share the same network namespace and storage volume. Containers in the same pod can communicate with each other through `localhost`.
5. ReplicaSets: ReplicaSets are used to ensure that a specified number of pod replicas are running at all times. They help with scaling and maintaining the desired number of instances of an application.
6. Services: Kubernetes Services define a logical set of pods and policies for accessing them. They provide a stable network endpoint for connecting to the pods, regardless of changes in the underlying infrastructure.
7. Namespaces: Namespaces are a way to partition resources in a cluster. They provide a scope for organizing and isolating objects like pods, services, and volumes.
Control Plane:
1. Master Node: The master node is the control plane of the Kubernetes cluster and manages the overall cluster state, including scheduling, scaling, and maintaining application availability.
2. Kube-API Server: This is the component of the master node that exposes the Kubernetes API and is responsible for receiving and processing requests from users and other components.
3. Etcd: A distributed key-value store that is used to store the configuration data for the entire cluster. It's the source of truth for all cluster data.
4. Kube-Scheduler: This component is responsible for scheduling pods to nodes based on resource requirements and constraints.
5. Kube-Controller-Manager: It manages different types of controllers that regulate the state of the system, such as ReplicaSets, Deployments, and Services.
6. Cloud Controller Manager: If the cluster is running in a cloud provider environment, this component manages interactions with the cloud provider's infrastructure.
Worker Nodes:
1. Kubelet: This agent runs on each worker node and is responsible for communicating with the control plane and ensuring that containers are running in pods as expected.
2. Container Runtime: Kubernetes is designed to be container-agnostic, but Docker is one of the most commonly used container runtimes.
3. Kube-Proxy: Kube-Proxy maintains network rules on worker nodes to allow network communication to your pods from network sessions inside or outside of your cluster.
Kubernetes Ecosystem:
Kubernetes has a vast ecosystem of tools and extensions that complement its core functionality, including Helm (a package manager for Kubernetes), Istio (for service mesh), and Prometheus (for monitoring and alerting), among others.
Kubernetes is a powerful and versatile platform for managing containerized applications. It simplifies many aspects of deploying and managing applications, making it a popular choice for organizations looking to build and scale container-based services.
Welcome & Introduction
From Monolith to Microservices
Container Orchestration
Kubernetes Tutorial for Beginners
Kubernetes and Container Orchestration 101 - Computer Stuff They Didn't Teach You #11
Part 1: Prerequisites – Kubernetes Foundations
Containers
you need to learn Kubernetes RIGHT NOW
Linux Kernel Features
Container User Experience
New Container Capabilities
Gaps using Containers in Production
Microservices
DevOps
Part 2: Core Concepts of Kubernetes
Cluster Orchestration Looking at K8S Origination at Google Open Source Benefits Design Principles
Part 3: Navigating Kubernetes Architecture
Master/Node
Kubectl
Kubernetes Tutorials For Beginners: 35 Comprehensive Guides
Replication Controller
Kubernetes - Replication Controller
Kubelet
What is the difference between kubectl and kubelet in Kubernetes?
Kube-Proxy Persistent Volumes Etcd High Availability
Part 4: Using Kubernetes Features
Pods Labels Services Namespaces Resource Quota
Part 5: Security and Kubernetes
Goals Roles Attribute-Based Access Control Policies Service Accounts Secrets
Part 6: Networking and Kubernetes
Docker Networking Kubernetes Networking Pod to Pod Exposing Services IP Per Pod Inter Pod Communication Intra Pod Communication
Part 7: Cluster Add-ons
Cluster DNS Logging with Elasticsearch and Fluentd Container Level Monitoring cAdvisor InfluxDB Prometheus
Part 8: Practical Kubernetes Examples
Hello World Wordpress Guestbook 3 Tier App Http/Https Load Balancing
Part 9: Continuous Integration with Kubernetes
Canary Release Blue Green Deployment A/B Testing Rolling Update Jenkins Plugin
Part 10: Roadmap/Beta
Ingress Deployments Autoscaling Jobs DaemonSets Network Plugins DNS
Part 11: Class conclusion – Implementation, Q and A, Next Steps
Discussion: What can you apply? How can Kubernetes help your situation Expert Q and A
Kubernetes
Kubernetes Architecture - Overview
Installing Kubernetes
Setting Up a Single Node Kubernetes Cluster Using Minikube
Accessing Minikube
Kubernetes Building Blocks
Services
Deploying a Stand-Alone Application
Kubernetes Volume Management
ConfigMaps and Secrets
Ingress
Advanced Topics - Overview
Kubernetes Community
Getting started with Kubernetes Install Docker EE UCP with Kubernetes Install UCP CLI Bundle Install Kubernetes Client Bundle Test kubectl commands Play with Kubernetes Brief overview of other installations’ options Kubernetes background Where did Kubernetes come from A data center OS
Kubernetes Architecture Masters and nodes Packaging apps The declarative model and desired state Pods Deployments Services
Pods Pod lab using both: UCP UI and command line
Deployments Deployments lab using both: UCP UI and command line
Services Services lab using both: UCP UI and command line
Storage The Container Storage Interface (CSI) The Kubernetes persistent volume subsystem Storage Classes and Dynamic Provisioning
ConfigMaps The big picture ConfigMap theory How do ConfigMaps work Hands-on with ConfigMaps
Security Docker security TLS and mutual authentication Configuring some CA settings Role-based access control (RBAC) Content Trust Enterprise-grade features Configuring Docker Trusted Registry (DTR) Using Docker Trusted Registry
A visual guide to Kubernetes networking fundamentals
Kubernetes, also known as K8s, 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 builds upon 15 years of experience of running production workloads at Google, combined with best-of-breed ideas and practices from the community.