Kubernetes
1 Pod = 1 or n containers
About Kubernetes
Kubernetes is an open-source container orchestration system for automating application deployment, scaling, and management. It was originally designed by Google, and is now maintained by the Cloud Native Computing Foundation.
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.
- Planet Scale
- Never Outgrow
- Run Anywhere
Kubernetes Topics
The following are the things covered under Kubernetes.
Understand the basics
Learn about Kubernetes and its fundamental concepts.
Try Kubernetes
Follow tutorials to learn how to deploy applications in Kubernetes.
Set up a cluster
Get Kubernetes running based on your resources and needs.
Learn how to use Kubernetes
Look up common tasks and how to perform them using a short sequence of steps.
Look up reference information
Browse terminology, command line syntax, API resource types, and setup tool documentation.
Extending Kubernetes Cluster
Kubernetes is highly configurable and extensible. As a result, there is rarely a need to fork or submit patches to the Kubernetes project code.
Course Contents
The following are the course contents offered for Kubernetes
- What is Kubernetes?
- What Kubernetes is not
- Understanding container orchestration
- Physical machines
- The benefits of containers
- Containers in the cloud
- Cattle versus pets
- Kubernetes concepts
- Cluster
- Node
- Master
- Pod
- Label
- Annotations
- Label selectors
- Replication controllers and replica sets
- Services
- Volume
- StatefulSet
- Secrets
- Names
- Namespaces
- Distributed systems design patterns
- Sidecar pattern
- Ambassador pattern
- Adapter pattern
- Multinode patterns
- Resource categories
- Workloads API
- Discovery and load balancing
- Config and storage
- Metadata
- Cluster
- Master components
- API server
- Etcd
- Kube controller manager
- Cloud controller manager
- Kube-scheduler
- DNS
- Node components
- Proxy
- Kubelet
- Kubernetes runtimes
- The Container Runtime Interface (CRI)
- Docker
- Rkt
- App container
- Cri-O
- Rktnetes
- Is rkt ready for use in production?
- Hyper containers
- Stackube
- Continuous integration and deployment
- What is a CI/CD pipeline?
- Designing a CI/CD pipeline for Kubernetes
- A quick single-node cluster with Minikube
- Getting ready
- On Linux
- On Windows
- Creating the cluster
- Troubleshooting
- Checking out the cluster
- Doing work
- Examining the cluster with the dashboard
- Creating a multinode cluster using kubeadm
- Setting expectations
- Getting ready
- Preparing a cluster of vagrant VMs
- Installing the required software
- The host file
- The vars.yml file
- The playbook.yml file
- Creating the cluster
- Initializing the master
- Setting up the pod network
- Adding the worker nodes
- Creating clusters in the cloud (GCP
- The cloud-provider interface
- Google Cloud Platform - (GCP)
- Amazon Web Services (AWS)
- Amazon Elastic Container Service for Kubernetes (EKS)
- Azure
- Creating a bare-metal cluster from scratch
- Container images
- Container registries
- Making your first container
- Dockerfile commands
- Example - Python/Flask container image
- Building the container
- Running your container
- Pod name
- Port forwarding
- Proxy
- How did the proxy know to connect to port 5000 on the container?
- Getting logs from your application
- Example - Node.js/Express container image
- Building the container
- Running your container
- Port forwarding
- Proxy
- Getting logs from your application
- Tagging your container images
- Installing Kubernetes on a Public Cloud Provider
- Installing Kubernetes Locally Using minikube
- The Kubernetes Client
- Cluster Components
- Pods
- Pods in Kubernetes
- Thinking with Pods
- The Pod Manifest
- Running Pods
- Accessing Your Pod
- Health Checks
- Resource Management
- Persisting Data with Volumes
- Putting It All Together
- Labels
- Applying Labels
- Modifying Labels
- Label Selectors
- Label Selectors in API Objects
- Annotations
- Cleanup
- What Is Service Discovery?
- The Service Object
- Looking Beyond the Cluster
- Cloud Integration
- Advanced Details
- Endpoints
- Manual Service Discovery
- kube-proxy and Cluster IPs
- Cluster IP Environment Variables
- Cleanup
- Reconciliation Loops
- Relating Pods and ReplicaSets
- Designing with ReplicaSets
- ReplicaSet Spec
- Creating a ReplicaSet
- Inspecting a ReplicaSet
- Scaling ReplicaSets
- Deleting ReplicaSets
- DaemonSet Scheduler
- Creating DaemonSets
- Limiting DaemonSets to Specific Nodes
- Updating a DaemonSet
- Deleting a DaemonSet
- The Job Object
- Job Patterns
- One Shot
- Parallelism
- Work Queues
- ConfigMaps
- Secrets
- Naming Constraints
- Managing ConfigMaps and Secrets
- Your First Deployment
- Creating Deployments
- Managing Deployments
- Updating Deployments
- Scaling a Deployment
- Updating a Container Image
- Rollout History
- Deployment Strategies
- Recreate Strategy
- RollingUpdate Strategy
- Slowing Rollouts to Ensure Service Health
- Deleting a Deployment
- Importing External Services
- Running Reliable Singletons
- Running a MySQL Singleton
- Dynamic Volume Provisioning
- Kubernetes-Native Storage with StatefulSets
- Properties of StatefulSets
- Manually Replicated MongoDB with StatefulSets
- Automating MongoDB Cluster Creation
- Persistent Volumes and StatefulSets
- One Final Thing: Readiness Probes
- Cost versus performance
- Managing cost on the cloud
- Managing cost on bare metal
- Managing cost on hybrid clusters
- Cost versus performance
- Managing cost on the cloud
- Managing cost on bare metal
- Managing cost on hybrid clusters
- High-availability concepts
- Redundancy
- Hot swapping
- Leader election
- Smart load balancing
- Idempotency
- Self-healing
- High-availability best practices
- Creating highly available clusters
- Making your nodes reliable
- Live cluster upgrades
- Rolling upgrades
- Complex deployments
- Blue-green upgrades
- Persistent volumes walk-through
- Volumes
- Using emptyDir for intra-pod communication
- Using HostPath for intra-node communication
- Using local volumes for durable node storage
- Provisioning persistent volumes
- Creating persistent volumes
- Storage classes
- Default storage class
- Demonstrating persistent volume storage end to end
- Public storage volume types - GCE
- AWS Elastic Block Store (EBS)
- AWS Elastic File System
- Azure data disk
- Running Stateful Applications with Kubernetes
- Stateful versus stateless applications in Kubernetes
- Understanding the nature of distributed data-intensive apps
- Why manage state in Kubernetes?
- Why manage state outside of Kubernetes?
- Shared environment variables versus DNS records for discovery
- Accessing external data stores via DNS
- Running a Cassandra cluster in Kubernetes
- Quick introduction to Cassandra
- The Cassandra Docker image
- Exploring the run.sh script
- Hooking up Kubernetes and Cassandra
- Digging into the Cassandra configuration
- Rolling Updates
- Horizontal pod autoscaling
- Declaring horizontal pod autoscaler
- Custom metrics
- Using custom metrics
- Autoscaling with kubectl
- Performing rolling updates with autoscaling
- Handling scarce resources with limits and quotas
- Understanding the Kubernetes networking model
- Intra-pod communication (container to container)
- Inter-pod communication (pod to pod)
- Pod-to-service communication
- External access
- Kubernetes networking versus Docker networking
- Lookup and discovery
- Self-registration
- Services and endpoints
- Loosely coupled connectivity with queues
- Loosely coupled connectivity with data stores
- Kubernetes ingress
- Kubernetes network plugins
- Understanding Helm
- The motivation for Helm
- The Helm architecture
- Helm components
- The Tiller server
- The Helm client
- Using Helm
- Installing Helm
- Installing the Helm client
- Installing the Tiller server
- Installing Tiller in-cluster
- Installing Tiller locally
- Using Alternative Storage Backend
- Finding charts
- Installing packages
- Checking installation status
- Customizing a chart
- Additional installation options
- Upgrading and rolling back a release
- Deleting a release
- Working with repositories
- Managing charts with Helm
- Taking advantage of starter packs
- Creating your own charts
- The Chart.yaml file
- Versioning charts
- The appVersion field
- Deprecating charts
- Chart metadata files
- Managing chart dependencies
- Managing dependencies with requirements.yaml
- Using special fields in requirements.yaml
- Using templates and values
- Writing template files
- Using pipelines and functions
- Embedding predefined values
- Feeding values from a file
- Scope
- Understanding Helm
- The motivation for Helm
- The Helm architecture
- Helm components
- The Tiller server
- The Helm client
- Using Helm
- Installing Helm
- Installing the Helm client
- Installing the Tiller server
- Installing Tiller in-cluster
- Installing Tiller locally
- Using Alternative Storage Backend
- Finding charts
- Installing packages
- Checking installation status
- Customizing a chart
- Additional installation options
- Upgrading and rolling back a release
- Deleting a release
- Working with repositories
- Managing charts with Helm
- Taking advantage of starter packs
- Creating your own charts
- The Chart.yaml file
- Versioning charts
- The appVersion field
- Deprecating charts
- Chart metadata files
- Managing chart dependencies
- Managing dependencies with requirements.yaml
- Using special fields in requirements.yaml
- Using templates and values
- Writing template files
- Using pipelines and functions
- Embedding predefined values
- Feeding values from a file
- Scope
- External load balancer
Download
Download Kubernetes course plan