Index

A

• access
  • limiting, namespace used / Using namespace to limit access
• adapter pattern
  • about / Adapter pattern
• admission control plugin
  • writing / Writing an admission control plugin
  • implementing / Implementing an admission control plugin
  • registering / Registering an admission control plugin
• admission control plugins
  • using / Using admission control plugins
  • AlwaysAdmit / Using admission control plugins
  • AlwaysDeny / Using admission control plugins
  • ImagePolicyWebhook / Using admission control plugins
  • ServiceAccount / Using admission control plugins
  • ResourceQuota / Using admission control plugins
  • LimitRanger / Using admission control plugins
  • InitialResources / Using admission control plugins
  • NamespaceLifecycle / Using admission control plugins
  • DefaultStorageClass / Using admission control plugins
• Alibaba Cloud
  • about / Alibaba Cloud
• ambassador pattern
  • about / Ambassador pattern
• annotations
  • about / Annotation
• API server
  • accessing / Accessing the API server
• AppArmor
  • cluster, protecting with / Protecting your cluster with AppArmor
  • pod, securing with / Securing a pod with AppArmor
• AppArmor profiles
  • writing / Writing AppArmor profiles
• Attribute-Based Access Control (ABAC) / Authorizing requests
• authorization plugin
  • writing / Writing an authorization plugin
  • admission control plugin / Writing an admission control plugin
  • custom metrics plugin / Writing a custom metrics plugin
  • volume plugin / Writing a volume plugin
• authorizer component / Authorizer
• automatic workflows
  • about / Automatic workflows
• autoscaling
  • with Kubectl / Autoscaling with Kubectl
  • rolling updates, performing with / Performing rolling updates with autoscaling
• autoscaling API
  • about / Autoscaling API
  • batch API / Batch API
• availability requirements / Availability requirements
• AWS
  • clusters, creating in / AWS
• AWS Elastic Block Store (EBS) / AWS Elastic Block Store (EBS)
• AWS Elastic Container Service (ECS) / AWS
• AWS Elastic File System (EFS) / AWS Elastic File System (EFS)
• Azure
  • clusters, creating in / Azure
  • about / Azure
• Azure cluster
  • reference / Azure
• Azure data disk / Azure data disk
• Azure file storage / Azure file storage

B

• bad configuration / Bad configuration
• bane
  • reference / Writing AppArmor profiles
• bare metal
  • cost, managing on / Managing cost on bare metal
• bare metal cluster
  • creating / Creating a bare-metal cluster from scratch
  • use cases / Use cases for bare-metal
  • considerations / When should you consider creating a bare-metal cluster?
• batch API
  • about / Batch API
• best effort / Best effort
• binary releases, Helm
  • reference / Installing the Helm client
• blue-green upgrades / Blue-green upgrades
• bridge plugin
  • reviewing / Reviewing the bridge plugin
• budget-aware workflows
  • about / Budget-aware workflows
• bundling / The value of bundling

C

• cAdvisor
  • about / cAdvisor
• cAdvisor UI
  • about / cAdvisor
• Calico
  • about / Canal, Calico project
• Canal
  • about / Canal
• Cassandra
  • about / Quick introduction to Cassandra
  • Kubernetes, connecting with / Hooking up Kubernetes and Cassandra
  • distributing, replication controller used / Using a replication controller to distribute Cassandra
  • distributing, DaemonSet used / Using DaemonSet to distribute Cassandra
• Cassandra cluster
  • running, in Kubernetes / Running a Cassandra cluster in Kubernetes
  • creating, statefulSet used / Using statefulSet to create the Cassandra cluster
  • stateful set configuration file, dissecting / Dissecting the stateful set configuration file
• Cassandra configuration
  • about / Digging into the Cassandra configuration
  • custom seed provider / The custom seed provider
• Cassandra Docker Image
  • about / The Cassandra Docker image
  • run.sh script, exploring / Exploring the run.sh script
• Cassandra headless service
  • creating / Creating a Cassandra headless service
• central logging
  • about / Adding central logging
  • planning / Planning central logging
• Ceph
  • about / GlusterFS and Ceph volumes in Kubernetes
  • using, as persistent volumes / Using Ceph
  • connecting to / Connecting to Ceph using RBD, Connecting to Ceph using CephFS
• CephFS
  • used, for connecting to Ceph / Connecting to Ceph using CephFS
• chart dependencies, Helm
  • dependencies, managing with requirements.yaml / Managing dependencies with requirements.yaml
  • special fields, utilizing in requirements.yaml / Utilizing special fields in requirements.yaml
• charts
  • managing, with Helm / Managing charts with Helm
• CI/CD pipeline
  • about / Continuous integration and deployment, What is a CI/CD pipeline?
  • designing, for Kubernetes / Designing a CI/CD pipeline for Kubernetes
• claims
  • mounting, as volumes / Mounting claims as volumes
• client IP address preservation
  • Load Balancer, annotating for / Annotating the load balancer for client IP address preservation
• cloud
  • containers / Containers in the cloud
  • clusters, creating in / Creating clusters in the cloud (GCP, AWS, Azure)
  • cost, managing on / Managing cost on the cloud
• cloud-provider interface / The cloud-provider interface
• cloud.go
  • reference / The cloud-provider interface
• Cloud bursting / Capacity overflow
• Cloud platforms / Cloud platforms
• cluster
  • about / Cluster
  • creating / Creating the cluster, The process
  • master, initializing / Initializing the master
  • creating, in cloud / Creating clusters in the cloud (GCP, AWS, Azure)
  • protecting, with AppArmor / Protecting your cluster with AppArmor
  • naming rules / Naming rules and customization
  • customization / Naming rules and customization
  • secret name / Secret name
  • custom scheduler, running in / Running another custom scheduler in the cluster
• cluster-level logging
  • about / Adding central logging
• cluster capacity
  • selecting / Choosing and managing the cluster capacity
  • managing / Choosing and managing the cluster capacity
  • node types, selecting / Choosing your node types
  • storage solutions, selecting / Choosing your storage solutions
  • multiple node configurations, using / Using effectively multiple node configurations
• clustered container data volume manager
  • Flocker, using as / Flocker as a clustered container data volume manager
• cluster federation
  • about / Understanding cluster federation
  • use cases / Important use cases for cluster federation
• cluster federation setup
  • about / Setting up cluster federation from the ground up
  • initial setup / Initial setup
  • official Hyperkube image, using / Using the official hyperkube image
  • federation control plane, running / Running the federation control plane
  • Kubernetes cluster, registering with federation / Registering Kubernetes clusters with federation
  • KubeDNS, updating / Updating KubeDNS
  • federation, shutting down / Shutting down the federation
• cluster federation setup, with Kubefed
  • about / Setting up cluster federation with Kubefed
  • host cluster, selecting / Choosing a host cluster
  • federation control plane, deploying / Deploying a federation control plane
  • cluster, adding to federation / Adding a cluster to a federation
  • cluster, removing from federation / Removing a cluster from a federation
  • federation, shutting down / Shutting down the federation
  • cascading delete of resources / Cascading delete of resources
  • load balancing, across multiple clusters / Load balancing across multiple clusters
  • failing, over multiple clusters / Failing over across multiple clusters
• clusters
  • preparing, of vagrant VMs / Preparing a cluster of vagrant VMs
• cluster state
  • protecting / Protecting your cluster state
• CNI plugin
  • about / CNI plugin
  • writing / Writing your own CNI plugin
• competitors, Kubernetes
  • Docker Swarm / Docker Swarm
  • Mesos/Mesosphere / Mesos/Mesosphere
  • Cloud platforms / Cloud platforms
  • AWS / AWS
  • Azure / Azure
  • Alibaba Cloud / Alibaba Cloud
• compute resource quota / Compute resource quota
• ConfigMap
  • creating / Creating a ConfigMap
  • consuming, as environment variable / Consuming a ConfigMap as an environment variable
• configuration and deployment challenges, Kubernetes
  • c / Configuration and deployment challenges
• configuration file
  • external load balancer, configuring via / Via configuration file
• container
  • secrets, using in / Using secrets in a container
• Container Networking Interface (CNI)
  • about / Container networking interface
  • container runtime / Container runtime
• container orchestration
  • about / Understanding container orchestration
• containers
  • about / Physical machines, virtual machines, and containers
• containers, in cloud
  • about / Containers in the cloud
• Contiv
  • about / Contiv
  • capabilities / Contiv
• controller manager
  • about / Controller manager
• CoreV1API group
  • dissecting / Dissecting the CoreV1API group
• cost
  • versus performance / Cost versus performance
  • managing, on cloud / Managing cost on the cloud
  • managing, on bare metal / Managing cost on bare metal
  • managing, on hybrid clusters / Managing cost on hybrid clusters
• cron jobs
  • scheduling / Scheduling cron jobs
• custom admission control plugin
  • linking / Linking your custom admission control plugin
• Custom Load Balancer provider
  • with HAProxy / Custom load balancer provider using HAProxy
• custom metrics
  • pod, configuring for / Configuring the pod for custom metrics
• custom metrics plugin
  • writing / Writing a custom metrics plugin
• custom scheduler
  • deploying / Deploying the custom scheduler
  • running, in cluster / Running another custom scheduler in the cluster
  • pods, assigning to / Assigning pods to the custom scheduler
• custom scheduler plugin
  • writing / Writing a custom scheduler plugin

D

• daemonSet
  • using, for redundant persistent storage / Using DaemonSet for redundant persistent storage
• DaemonSet / DaemonSet
  • used, for distributing Cassandra / Using DaemonSet to distribute Cassandra
• DaemonSet pods / Sharing with DaemonSet pods
• data stores / Data stores
• default compute quotas
  • limit ranges, using for / Using limit ranges for default compute quotas
• default storage class / Default storage class
• dependencies
  • managing, readiness probes used / Using readiness probes to manage dependencies
• deployment
  • updating / Updating a deployment
• distributed data-intensive apps
  • about / Understanding the nature of distributed data-intensive apps
• distributed systems design patterns, Kubernetes
  • about / Distributed systems design patterns
  • sidecar pattern / Sidecar pattern
  • ambassador pattern / Ambassador pattern
  • adapter pattern / Adapter pattern
  • multi-node patterns / Multi-node patterns
• DNS / DNS
  • external data stores, accessing via / Accessing external data stores via DNS
• Docker
  • about / Docker, Docker Swarm
• Docker networking
  • versus Kubernetes networking / Kubernetes networking versus Docker networking
• Docker Swarm
  • about / Docker Swarm
• dynamic plugins
  • about / Dynamic plugins

E

• elastic cloud resources
  • benefitting from / Benefiting from elastic cloud resources
  • instances, autoscaling / Autoscaling instances
  • cloud quotas / Mind your cloud quotas
  • regions, managing / Manage regions carefully
• Elasticsearch
  • about / Elasticsearch
• emptyDir
  • using, for intra-pod communication / Using emptyDir for intra-pod communication
• endpoints
  • about / Services and endpoints
• enterprise
  • Hue, utilizing in / Utilizing Hue in the enterprise
• enterprise storage
  • integrating, into Kubernetes / Integrating enterprise storage into Kubernetes
• envelope
  • pushing, with Kubernetes / Pushing the envelope with Kubernetes
• environment variable
  • ConfigMap, consuming as / Consuming a ConfigMap as an environment variable
• environment variables
  • external data stores, accessing via / Accessing external data stores via environment variables
• etcd
  • about / Etcd, Creating highly available clusters, Flannel
• etcd, clustering
  • about / Clustering etcd
  • static discovery / Static discovery
  • etcd discovery / Etcd discovery
  • DNS discovery / DNS discovery
• etcd.yaml file / The etcd.yaml file
• etcd 2
  • versus etcd 3 / etcd 2 versus etcd 3
• etcd 3
  • versus etcd 2 / etcd 2 versus etcd 3
• etcd cluster
  • verifying / Verifying the etcd cluster
• etcd discovery
  • reference / Etcd discovery
• External APIs / Deprecating APIs
• external data stores
  • accessing, via DNS / Accessing external data stores via DNS
  • accessing, via environment variables / Accessing external data stores via environment variables
• external load balancer
  • configuring / Configuring an external load balancer
  • configuring, via configuration file / Via configuration file
  • configuring, via Kubectl / Via Kubectl
  • client IP addresses, identifying / Identifying client IP addresses
• external Load Balancer / External load balancer
• external service / External service

F

• failures
  • handling, with federated ingress / Handling failures with federated ingress
• federated auto-calling / Federated auto-scaling
• federated ConfigMap
  • about / Federated ConfigMap
  • creating / Creating a federated ConfigMap
  • viewing / Viewing a federated ConfigMap
  • updating / Updating a federated ConfigMap
  • deleting / Deleting a federated ConfigMap
• federated DaemonSet
  • about / Federated DaemonSet
• federated data access
  • about / Federated data access
• federated deployment
  • about / Federated deployment
• federated events
  • about / Federated events
• federated ingress
  • about / Federated ingress
  • roles / Federated ingress
  • creating / Creating a federated ingress
  • request routing, performing with / Request routing with a federated ingress
  • failures, handling with / Handling failures with federated ingress
• federated migration
  • about / Federated migration
• federated namespace
  • about / Federated namespace
• federated ReplicaSet
  • about / Federated ReplicaSet
• federated resources
  • about / Federated resources
• federated secrets
  • about / Federated secrets
• federated service
  • creating / Creating a federated service
  • discovering / Discovering a federated service
  • DNS expansion / DNS expansion
• federated service discovery
  • about / Federated service discovery
• federated unit of work
  • about / Federated unit of work
• federated workloads
  • running / Running federated workloads
  • backend pods, adding / Adding backend pods
  • public DNS records, verifying / Verifying public DNS records
  • failures of backend pods, handling / Handling failures of backend pods and whole clusters
  • whole clusters, handling / Handling failures of backend pods and whole clusters
• federation
  • location affinity / Location affinity
  • cross-cluster scheduling / Cross-cluster scheduling
• federation API server
  • about / Federation API server
  • unable to connect issue / Unable to connect to federation API server
• federation controller manager
  • about / Federation controller manager
• federation control plane
  • about / Understanding cluster federation, The federation control plane
• Flannel
  • about / Flannel
• Flocker
  • using, as clustered container data volume manager / Flocker as a clustered container data volume manager
• Fluentd
  • about / Fluentd
• fluentd-elasticsearch add-on
  • reference / Planning central logging

G

• GCE persistent disk / GCE persistent disk
• GCP
  • clusters, creating in / GCP
• generic actuator / Generic actuator
• generic sensor / Generic sensor
• GlusterFS
  • about / GlusterFS and Ceph volumes in Kubernetes
  • using, as persistent volumes / Using GlusterFS
  • endpoints, creating / Creating endpoints
  • pods, creating / Creating pods
• GlusterFS Kubernetes service
  • adding / Adding a GlusterFS Kubernetes service
• Google Kubernetes Engine (GKE)
  • about / GCP
• Grafana visualization
  • about / Grafana visualization

H

• HAProxy
  • about / HAProxy
  • running, inside Kubernetes cluster / Running HAProxy Inside the Kubernetes cluster
• hardware failures, Kubernetes / Hardware failure
• Heapster
  • about / Monitoring Kubernetes with Heapster
  • Kubernetes, monitoring with / Monitoring Kubernetes with Heapster
• Helm
  • about / Understanding Helm
  • uses cases / The motivation for Helm
  • versus Helm-classic / Helm versus. Helm-classic
  • using / Using Helm
  • installing / Installing Helm
  • charts, finding / Finding charts
  • packages, installing / Installing packages
  • installation status, checking / Checking installation status
  • chart customization / Customizing a chart
  • additional installation options / Additional installation options
  • release, rolling back / Upgrading and rolling back a release
  • package, upgrading / Upgrading and rolling back a release
  • release, deleting / Deleting a release
  • repositories, managing / Working with repositories
  • charts, managing with / Managing charts with Helm
  • starter packs, for charts / Taking advantage of starter packs
  • charts, creating / Creating your own charts
  • Chart.yaml file / The Chart.yaml file
  • charts, versioning / Versioning charts
  • charts, deprecating / Deprecating charts
  • chart metadata files / Chart metadata files
  • chart dependencies, managing / Managing chart dependencies
  • templates, using / Using templates and values
  • values, using / Using templates and values
  • template files, writing / Writing template files
  • pipelines, using / Using pipelines and functions
  • functions, using / Using pipelines and functions
  • predefined values, embedding / Embedding predefined values
  • values, feeding from file / Feeding values from a file
  • scope / Scope, dependencies, and values
  • value files, declaring / Scope, dependencies, and values
• Helm-classic
  • reference / Helm versus. Helm-classic
• Helm architecture
  • about / The Helm architecture
• Helm client
  • installing / The Helm client, Installing the Helm client
• Helm components
  • about / Helm components
• high-availability
  • testing / Testing high-availability
• High-Availability (HA) Proxy
  • about / HAProxy
• high-availability, best practices
  • about / High-availability best practices
  • highly available clusters, creating / Creating highly available clusters
  • nodes, making reliable / Making your nodes reliable
  • cluster state, protecting / Protecting your cluster state
  • data, protecting / Protecting your data
  • redundant API servers, running / Running redundant API servers
  • leader election, running with Kubernetes / Running leader election with Kubernetes
  • staging environment, making highly available / Making your staging environment highly available
• high-availability, concepts
  • about / High-availability concepts
  • redundancy / Redundancy
  • hot swapping / Hot swapping
  • leader election / Leader election
  • smart load balancing / Smart load balancing
  • idempotency / Idempotency
  • self-healing / Self-healing
• Highly Available (HA) Kubernetes clusters / AWS
• horizontal pod autoscaler
  • declaring / Declaring horizontal pod autoscaler
• horizontal pod autoscaling
  • about / Horizontal pod autoscaling
  • custom metrics / Custom metrics
• HostPath
  • using, for intra-node communication / Using HostPath for intra-node communication
• hot swapping / Hot swapping
• httpie
  • output, filtering with / Filtering the output with httpie and jq
  • reference / Filtering the output with httpie and jq
• Hue
  • scope, designing of / Defining the scope of Hue
  • utilizing, in enterprise / Utilizing Hue in the enterprise
  • science, advancing with / Advancing science with Hue
  • utilizing, for education / Educating the kids of the future with hue
• Hue-reminders service
  • creating / Creating the Hue-reminders service
• Hue components
  • about / Hue components
  • user profile / User profile
  • user graph / User graph
  • identity management / Identity
  • authorizer / Authorizer
  • external service / External service
  • generic sensor / Generic sensor
  • generic actuator / Generic actuator
  • user learner / User learner
• Hue microservices
  • about / Hue microservices
  • plugins / Plugins
  • data stores / Data stores
  • stateless microservices / Stateless microservices
  • queue-based interactions / Queue-based interactions
• Hue platform
  • designing / Designing the Hue platform
  • building, Kubernetes used / Using Kubernetes to build the Hue platform
  • managing, with Kubernetes / Managing the Hue platform with Kubernetes
  • evolving, with Kubernetes / Evolving the Hue platform with Kubernetes
• human workflows
  • about / Human workflows
• hybrid clusters
  • cost, managing on / Managing cost on hybrid clusters
• Hyper.sh
  • about / Considering Hyper.sh
• hyper containers
  • about / Hyper containers
• Hypernetes
  • about / Hypernetes

I

• idempotency
  • about / Idempotency
• identity management / Identity
• image challenges, Kubernetes / Image challenges
• ImagePolicyWebHook / Using admission control plugins
• ImagePullSecrets
  • used, for securing pods / ImagePullSecrets
• InfluxDB
  • about / InfluxDB backend
• InfluxDB storage schema
  • about / The storage schema
  • CPU / CPU
  • filesystem / Filesystem
  • memory / Memory
  • network / Network
  • uptime / Uptime
• Ingress
  • about / Ingress, Ingress
  • using / Ingress
• init containers
  • employing, for orderly pod bring-up / Employing init containers for orderly pod bring-up
• inside-the-cluster-network components / Inside-the-cluster-network components
• inter-pod communication (pod to pod)
  • about / Inter-pod communication (pod to pod)
• internal, and external services
  • separating / Separating internal and external services
• Internal APIs / Deprecating APIs
• internal service
  • deploying / Deploying an internal service
• intra-node communication
  • HostPath, using for / Using HostPath for intra-node communication
• intra-pod communication
  • emptyDir, using for / Using emptyDir for intra-pod communication
• intra-pod communication (container to container)
  • about / Intra-pod communication (container to container)

J

• Java Management Extensions (JMX) / Exploring the run.sh script
• jobs
  • launching / Launching jobs
  • running, in parallel / Running jobs in parallel
  • completed jobs, cleaning up / Cleaning up completed jobs
  • cron jobs, scheduling / Scheduling cron jobs
• jq
  • output, filtering with / Filtering the output with httpie and jq
  • reference / Filtering the output with httpie and jq
• jq program
  • reference / Leader election for your application
• Juju
  • about / Kubernetes releases and milestones

K

• KataCoda
  • reference / Education and training
• Keepalived Virtual IP (VIP)
  • about / Keepalived VIP
• Kibana
  • about / Kibana
• kube-scheduler / Scheduler
• kubeadm
  • used, for creating multi-node cluster / Creating a multi-node cluster using kubeadm
• kube API server / API server
• Kubectl
  • reference / Getting ready
  • using, effectively / Using Kubectl effectively
  • generic commands / Using Kubectl effectively
  • cluster management commands / Using Kubectl effectively
  • troubleshooting commands / Using Kubectl effectively
  • deployment commands / Using Kubectl effectively
  • settings commands / Using Kubectl effectively
  • misc commands / Using Kubectl effectively
  • autoscaling with / Autoscaling with Kubectl
  • external load balancer, configuring via / Via Kubectl
  • proxy, setting up / Setting up a proxy
  • invoking, programmatically / Invoking Kubectl programmatically
  • running, Python subprocess used / Using Python subprocess to run Kubectl
• Kubectl get pods / Kubectl get pods
• Kubectl resource configuration files
  • about / Understanding Kubectl resource configuration files
  • ApiVersion / ApiVersion
  • kind / Kind
  • metadata / Metadata
  • spec / Spec
  • container spec / Container spec
• Kubefed
  • obtaining / Getting Kubefed
• kubelet
  • about / Kubelet
• Kubemark
  • about / Introducing the Kubemark tool
• Kubemark cluster
  • setting up / Setting up a Kubemark cluster
  • comparing, to real-world cluster / Comparing a Kubemark cluster to a real-world cluster
• Kubenet
  • about / Kubenet
  • requisites / Requirements
  • MTU, setting / Setting the MTU
• kube proxy / Proxy
• Kubernetes
  • cattle approach, versus pet approach / Cattle versus pets
  • node components / Node components
  • runtime interface / The runtime interface
  • CI/CD pipeline, designing for / Designing a CI/CD pipeline for Kubernetes
  • monitoring, with Heapster / Monitoring Kubernetes with Heapster
  • hardware failures / Hardware failure
  • leader election, running with / Running leader election with Kubernetes
  • security challenges / Understanding Kubernetes security challenges
  • node challenges / Node challenges
  • network challenges / Network challenges
  • image challenges / Image challenges
  • configuration and deployment challenges / Configuration and deployment challenges
  • multi-container pod challenges / Pod and container challenges
  • organizational challenges / Organisational, cultural, and process challenges
  • secrets, storing in / Storing secrets in Kubernetes
  • used, for building hue platform / Using Kubernetes to build the Hue platform
  • Hue platform, managing with / Managing the Hue platform with Kubernetes
  • Hue platform, evolving with / Evolving the Hue platform with Kubernetes
  • enterprise storage, integrating into / Integrating enterprise storage into Kubernetes
  • stateful application, versus stateless application / Stateful versus stateless applications in Kubernetes
  • reasons, for managing states / Why manage states in Kubernetes?
  • Cassandra cluster, running in / Running a Cassandra cluster in Kubernetes
  • connecting, with Cassandra / Hooking up Kubernetes and Cassandra
  • envelope, pushing with / Pushing the envelope with Kubernetes
  • performance, improving / Improving the performance and scalability of Kubernetes
  • scalability, improving / Improving the performance and scalability of Kubernetes
  • reads, caching in API server / Caching reads in the API server
  • pod lifecycle event generator / The pod lifecycle event generator
  • testing, at scale / Testing Kubernetes at scale
  • future / The road ahead
  • releases / Kubernetes releases and milestones
  • changes, in 1.7 release / Kubernetes releases and milestones
  • working groups / Kubernetes special interest and working groups
  • competitors / Competition
  • online tutorials / Education and training
• Kubernetes, concepts
  • about / Kubernetes concepts
  • cluster / Cluster
  • node / Node
  • master / Master
  • pod / Pod
  • label / Label
  • annotation / Annotation
  • label selector / Label selector
  • replication controller / Replication controller and replica set
  • replica set / Replication controller and replica set
  • service / Service
  • volume / Volume
  • PetSet / StatefulSet
  • secret / Secret
  • name / Name
  • namespace / Namespace
• kubernetes-anywhere / Azure
• Kubernetes API
  • about / Kubernetes API
  • query parameters / Kubernetes API
  • working with / Working with the Kubernetes API
  • OpenAPI / Understanding OpenAPI
  • exploring / Exploring the Kubernetes API directly
  • exploring, Postman used / Using Postman to explore the Kubernetes API
  • pod, creating via / Creating a pod via the Kubernetes API
  • accessing, via Python client / Accessing the Kubernetes API via the Python client
  • extending / Extending the Kubernetes API
• Kubernetes APIs
  • about / The Kubernetes APIs
  • autoscaling API / Autoscaling API
• Kubernetes architecture
  • about / Diving into Kubernetes architecture in depth
  • distributed systems design patterns / Distributed systems design patterns
• Kubernetes cluster
  • HAProxy, running inside / Running HAProxy Inside the Kubernetes cluster
• Kubernetes cluster federation
  • about / Understanding cluster federation
  • managing / Managing a Kubernetes cluster federation
• Kubernetes cluster level
  • configuration problems / Bad configuration
• Kubernetes components
  • about / Kubernetes components
  • master components / Master components, DNS
• Kubernetes contrib project
  • reference / Keepalived VIP
• Kubernetes dashboard
  • features / Performance analysis with the dashboard
  • top-level view / Top-level view
• Kubernetes ingress / Kubernetes ingress
• Kubernetes Kops project
  • reference / AWS
• Kubernetes momentum
  • about / The Kubernetes momentum
  • community / Community
  • Github / GitHub
  • conferences / Conferences and meetups
  • meetups / Conferences and meetups
  • mindshare / Mindshare
  • ecosystem / Ecosystem
  • public Cloud providers / Public Cloud providers
• Kubernetes networking
  • versus Docker networking / Kubernetes networking versus Docker networking
• Kubernetes networking model
  • about / Understanding the Kubernetes networking model
  • intra-pod communication (container to container) / Intra-pod communication (container to container)
  • inter-pod communication (pod to pod) / Inter-pod communication (pod to pod)
  • pod to service communication / Pod to service communication
  • external access / External access
• Kubernetes networking solutions
  • about / Kubernetes networking solutions
  • bridging on bare metal clusters / Bridging on bare metal clusters
  • Contiv / Contiv
  • Open vSwitch / Open vSwitch
  • Nuage networks VCS / Nuage networks VCS
  • Canal / Canal
  • Flannel / Flannel
  • Calico project / Calico project
  • Romana / Romana
  • Weave net / Weave net
• Kubernetes network plugins
  • about / Kubernetes network plugins
  • basic Linux networking / Basic Linux networking
  • IP addresses / IP addresses and ports
  • ports / IP addresses and ports
  • network namespaces / Network namespaces
  • Virtual Ethernet (veth) devices / Virtual Ethernet devices
  • bridges / Bridges
  • routing / Routing
  • Maximum Transmission Unit (MTU) / Maximum transmission unit
  • pod networking / Pod networking
• Kubernetes network policy design
  • using / Understanding the Kubernetes network policy design
• Kubernetes plugins
  • writing / Writing Kubernetes plugins
  • custom scheduler plugin / Writing a custom scheduler plugin
• Kubernetes runtimes
  • about / Kubernetes runtimes
  • Docker / Docker
  • Rkt / Rkt
  • Hyper containers / Hyper containers
• Kubernetes scheduler
  • design / Understanding the design of the Kubernetes scheduler
  • about / The scheduler
  • algorithm provider, registering / Registering an algorithm provider
  • configuring / Configuring the scheduler
  • packaging / Packaging the scheduler

L

• labels
  • about / Label
  • pods, decorating with / Decorating pods with labels
• label selectors
  • about / Label selector
• large-cluster
  • performance / Large-cluster performance, cost, and design trade-offs
  • cost / Large-cluster performance, cost, and design trade-offs
  • design trade-offs / Large-cluster performance, cost, and design trade-offs
• leader election / Leader election
  • running, with Kubernetes / Running leader election with Kubernetes
  • for application / Leader election for your application
• limit
  • scarce resources, handling with / Handling scarce resources with limits and quotas
• limit ranges
  • using, for default compute quotas / Using limit ranges for default compute quotas
• limits / Quotas, shares, and limits
  • about / Requests and limits
• live cluster upgrades
  • about / Live cluster upgrades
  • upgrades, rolling / Rolling upgrades
  • blue-green upgrades / Blue-green upgrades
  • data-contract changes, managing / Managing data-contract changes
  • data migration / Migrating data
  • APIs, deprecating / Deprecating APIs
• liveness probes
  • using / Using liveness probes to ensure your containers are alive
• Load Balancer
  • IP addresses, finding / Finding the load balancer IP addresses
  • annotating, for client IP address preservation / Annotating the load balancer for client IP address preservation
• load balancing
  • about / Load balancing options
  • options / Load balancing options
• location affinity, federation
  • strictly-coupled / Strictly-coupled
  • loosely-coupled / Loosely-coupled
  • preferentially-coupled / Preferentially-coupled
  • strictly-decoupled / Strictly-decoupled
  • uniformly-spread / Uniformly-spread
• long-running microservices
  • deploying, in pods / Deploying long-running microservices in pods
• long- running processes
  • deploying / Deploying long- running processes with deployments
• lookup and discovery
  • about / Lookup and discovery
  • self-registration / Self-registration
• loopback plugin
  • about / First look at the loopback plugin
  • building, on CNI plugin skeleton / Building on the CNI plugin skeleton
• loosely coupled connectivity
  • with queues / Loosely coupled connectivity with queues
  • with data stores / Loosely coupled connectivity with data stores

M

• maintenance windows / Maintenance windows
• master
  • about / Master
• master components, Kubernetes
  • about / Master components
  • API server / API server
  • etcd / Etcd
  • scheduler / Scheduler
  • DNS / DNS
• Mesos / Mesos/Mesosphere
• Mesosphere
  • about / Mesos/Mesosphere
• Minikube
  • quick single-node cluster / Quick single-node cluster with Minikube
  • reference / Getting ready
• Minikube cluster
  • configuration / Using Kubectl effectively
• minions
  • about / Node
• multi-container pod challenges, Kubernetes
  • c / Pod and container challenges
• multi-node cluster
  • creating, kubeadm used / Creating a multi-node cluster using kubeadm
  • required software, installing / Installing the required software
  • pod network, setting up / Setting up the pod network
  • worker nodes, adding / Adding the worker nodes
• multi-node patterns
  • about / Multi-node patterns
• multi-user cluster
  • running / Running a multi-user cluster
  • use cases / The case for a multi-user cluster
  • namespaces, using for safe multi-tenancy / Using namespaces for safe multi-tenancy
  • namespace pitfalls, avoiding / Avoiding namespace pitfalls

N

• name
  • about / Name
• namespace
  • about / Namespace
  • used, for limiting access / Using namespace to limit access
• namespace-specific context
  • using / Using namespace-specific context
• network challenges, Kubernetes / Network challenges
• networking solution
  • selecting / Choosing a supported networking solution
• network policies
  • managing / Managing network policies
  • defining / Defining a network policy
  • using, effectively / Using network policies effectively
  • and CNI plugins / Network policies and CNI plugins
  • configuring / Configuring network policies
  • implementing / Implementing network policies
• node
  • about / Node
• node challenges, Kubernetes / Node challenges
• node components, Kubernetes
  • about / Node components
  • proxy / Proxy
  • kubelet / Kubelet
• NodePort
  • utilizing / Utilizing the NodePort
• node problem detector
  • about / Node problem detector
  • problem daemons / Problem Daemons
• node problems
  • detecting / Detecting node problems
• nodes
  • pods, assigning to / Assigning pods to nodes
• non-cluster components
  • mixing / Mixing non-cluster components
• Nuage networks VCS
  • about / Nuage networks VCS

O

• object count quota / Object count quota
• objects
  • listing / Listing objects
  • creating / Creating objects
  • watching / Watching objects
• OpenAPI
  • about / Understanding OpenAPI
• Open Container Initiative (OCI)
  • about / Docker
• OpenShift
  • about / OpenShift
• OpenStack
  • about / OpenStack
• Open vSwitch
  • about / Open vSwitch
  • features / Open vSwitch
• organizational challenges, Kubernetes / Organisational, cultural, and process challenges
• outside-the-cluster-network components / Outside-the-cluster-network components

P

• performance
  • versus cost / Cost versus performance
• performance analysis, with dashboard
  • about / Performance analysis with the dashboard
• persistent volume claims
  • applying / Applying persistent volume claims
• persistent volumes
  • about / Persistent volumes walkthrough
  • provisioning / Provisioning persistent volumes
  • provisioning, statically / Provisioning persistent volumes statically
  • provisioning, dynamically / Provisioning persistent volumes dynamically
  • creating / Creating persistent volumes
  • capacity / Capacity
  • access modes / Access modes
  • reclaim policy / Reclaim policy
  • volume type / Volume type
  • sample claim / Making persistent volume claims
• persistent volume storage end to end
  • demonstrating / Demonstrating persistent volume storage end to end
• PetSet
  • about / StatefulSet
• physical machines
  • about / Physical machines, virtual machines, and containers
• plugins / Plugins
• pod
  • about / Pod
  • securing, with AppArmor / Securing a pod with AppArmor
  • creating, via Kubernetes API / Creating a pod via the Kubernetes API
  • configuring, for custom metrics / Configuring the pod for custom metrics
• Pod Lifecycle Event Generator (PLEG) / The pod lifecycle event generator
• pods
  • securing / Securing pods
  • securing, private image repository used / Using a private image repository
  • securing, ImagePullSecrets used / ImagePullSecrets
  • long-running microservices, deploying in / Deploying long-running microservices in pods
  • creating / Creating pods
  • decorating, with labels / Decorating pods with labels
  • assigning, to nodes / Assigning pods to nodes
  • assigning, to custom scheduler / Assigning pods to the custom scheduler
  • verifying / Verifying that the pods were scheduled using custom scheduler
• Pod security policy (PSP) / Pod security policies
• pod to service communication
  • about / Pod to service communication
• Postman
  • about / Using Postman to explore the Kubernetes API
  • reference / Using Postman to explore the Kubernetes API
  • used, for exploring Kubernetes API / Using Postman to explore the Kubernetes API
• private image repository
  • used, for securing pods / Using a private image repository
• public Cloud providers
  • OpenShift / OpenShift
  • OpenStack / OpenStack
• public storage volume types
  • about / Public storage volume types - GCE, AWS, and Azure
  • AWS Elastic Block Store (EBS) / AWS Elastic Block Store (EBS)
  • AWS Elastic File System (EFS) / AWS Elastic File System (EFS)
  • GCE persistent disk / GCE persistent disk
  • Azure data disk / Azure data disk
  • Azure file storage / Azure file storage
• Python client
  • Kubernetes API, accessing via / Accessing the Kubernetes API via the Python client
• Python client library
  • reference / Accessing the Kubernetes API via the Python client
• Python subprocess
  • used, for running Kubectl / Using Python subprocess to run Kubectl

Q

• Queries Per Second (QPS) / Writing a custom metrics plugin
• queries per second (qps) / Custom metrics
• query parameters, Kubernetes API
  • pretty / Kubernetes API
  • labelSelector / Kubernetes API
  • watch / Kubernetes API
  • resourceVersion / Kubernetes API
  • timeoutSeconds / Kubernetes API
• queue-based interactions / Queue-based interactions
• quick recovery / Quick recovery
• quick single-node cluster, Minikube
  • about / Quick single-node cluster with Minikube
  • pre-requisites / Getting ready
  • creating / Creating the cluster
  • troubleshooting / Troubleshooting
  • checking out / Checking out the cluster
  • working / Doing work
  • examining, with dashboard / Examining the cluster with the dashboard
• quotas / Quotas, shares, and limits
  • scarce resources, handling with / Handling scarce resources with limits and quotas
  • scopes / Quota scopes
  • working with / Working with quotas
  • creating / Creating quotas

R

• Rados Block Device (RBD)
  • used, for connecting to Ceph / Connecting to Ceph using RBD
• readiness probes
  • used, for managing dependencies / Using readiness probes to manage dependencies
• redundancy / Redundancy
• redundant API servers
  • running / Running redundant API servers
• redundant in-memory state
  • using / Using a redundant in-memory state
• redundant persistent storage
  • daemonSet, using for / Using DaemonSet for redundant persistent storage
• replica set
  • about / Replication controller and replica set
• replication controller configuration file
  • dissecting / Dissecting the replication controller configuration file
• replication controllers
  • about / Replication controller and replica set
  • used, for distributing Cassandra / Using a replication controller to distribute Cassandra
• request routing
  • with federated ingress / Request routing with a federated ingress
• requests
  • authorizing / Authorizing requests
  • about / Requests and limits
• required files, multi-node cluster
  • hosts file / The hosts file
  • vars.yml file / The vars.yml file
  • playbook.yml file / The playbook.yml file
• resource quotas
  • enabling / Enabling resource quotas
  • types / Resource quota types
  • compute resource quota / Compute resource quota
  • storage resource quota / Storage resource quota
  • object count quota / Object count quota
• rkt
  • production usage / Is rkt ready for production usage?
• Rkt
  • about / Rkt
  • app container / App container
• Rktnetes
  • about / Rktnetes
• robust systems
  • designing / Designing robust systems
• Roles-Based Access Control (RBAC) / Authorizing requests
• rolling updates
  • performing, with autoscaling / Performing rolling updates with autoscaling
• Romana
  • about / Romana

S

• scarce resources
  • handling, with limit / Handling scarce resources with limits and quotas
  • handling, with quotas / Handling scarce resources with limits and quotas
• science
  • advancing, with Hue / Advancing science with Hue
• scope
  • designing, of Hue / Defining the scope of Hue
• secret
  • about / Secret
• secrets
  • using / Using secrets
  • storing, in Kubernetes / Storing secrets in Kubernetes
  • creating / Creating secrets
  • decoding / Decoding secrets
  • using, in container / Using secrets in a container
• security challenges, Kubernetes / Understanding Kubernetes security challenges
• security context
  • specifying / Specifying a security context
• self-healing / Self-healing
• self-registration
  • about / Self-registration
  • benefits / Self-registration
• service
  • about / Service
  • exposing, externally / Exposing a service externally
• service-loadbalancer project
  • reference / HAProxy
• service accounts
  • about / Understanding service accounts in Kubernetes
  • managing / How does Kubernetes manage service accounts?
• Service Level Objectives (SLOs) / The Kubernetes SLOs
• service load balancer
  • about / Service load balancer
• shared environment variables
  • versus DNS records for discovery / Shared environment variables versus DNS records for discovery
• shares / Quotas, shares, and limits
• sidecar pattern
  • about / Sidecar pattern
• Single Point Of Failure (SPOF)
  • about / Strictly-decoupled
• single point of failure (SPOF) / Assigning pods to nodes
• smart load balancing / Smart load balancing
• Software-Defined Networking (SDN)
  • about / Nuage networks VCS
• spec / Spec
• stateful application
  • versus stateless application / Stateful versus stateless applications in Kubernetes
• statefulSet
  • used, for creating Cassandra cluster / Using statefulSet to create the Cassandra cluster
• StatefulSet controller
  • utilizing / Utilizing StatefulSet
  • using, factors / When to use StatefulSet
  • components / The components of StatefulSet
• stateless microservices / Stateless microservices
• states
  • managing, in Kubernetes / Why manage states in Kubernetes?
  • managing, outside of Kubernetes / Why manage states outside of Kubernetes?
• Storage Area Network (SAN) / Integrating enterprise storage into Kubernetes
• storage classes
  • about / Storage classes
  • default storage class / Default storage class
• storage resource quota / Storage resource quota

T

• third-party-resource
  • structure / Understanding the structure of a third-party-resource
  • developing / Developing third-party-resources
  • integrating / Integrating third party resources
• Tigera
  • about / Canal
• Tiller
  • installing, locally / Installing Tiller locally
• Tiller In-Cluster
  • installing / Installing Tiller in-cluster
• Tiller Server
  • installing / Installing the Tiller server
• Tiller server
  • about / The Tiller server
• Token Controller / How does Kubernetes manage service accounts?
• top-level view, Kubernetes dashboard
  • about / Top-level view
  • Admin view / Admin view
  • Workloads category / Workloads
  • Services and Discovery category / Services and discovery
• Torus
  • about / Torus – the new kid on the block
• troubleshooting scenarios
  • about / Troubleshooting scenarios

U

• Udacity courses, on Kubernetes
  • reference / Education and training
• UDP
  • about / Flannel
• UID (unique identifier) / Authenticating users
• upgrades
  • rolling / Rolling upgrades
  • complex deployments / Complex deployments
• use cases, cluster federation
  • capacity overflow / Capacity overflow
  • sensitive workloads / Sensitive workloads
  • vendor lock-in, avoiding / Avoiding vendor lock-in
  • geo-distributing high availability / Geo-distributing high availability
• user graph component / User graph
• user learner / User learner
• user profile component / User profile
• users
  • authenticating / Authenticating users

V

• vagrant VMs
  • clusters, preparing of / Preparing a cluster of vagrant VMs
• VirtualBox
  • reference / Getting ready
• virtual Ethernet (veth) devices / Virtual Ethernet devices
• Virtualized Cloud Services (VCS)
  • about / Nuage networks VCS
• virtual machines
  • about / Physical machines, virtual machines, and containers
• virtual private cloud infrastructure
  • using / Using virtual private cloud infrastructure
• Virtual Redundancy Router Protocol (VRRP) / Keepalived VIP
• volume
  • about / Volume
• volume plugin
  • writing / Writing a volume plugin
  • implementing / Implementing a volume plugin
  • registering / Registering a volume plugin
  • linking / Linking a volume plugin
• volumes
  • about / Volumes
  • emptyDir, using for intra-pod communication / Using emptyDir for intra-pod communication
  • HostPath, using for intra-node communication / Using HostPath for intra-node communication
  • claims, mounting as / Mounting claims as volumes

W

• Weave Net
  • about / Weave net
• workflows
  • planning / Planning workflows
  • automatic workflows / Automatic workflows
  • human workflows / Human workflows
  • budget-aware workflows / Budget-aware workflows

Z

• zero-downtime
  • plan / Zero-downtime
• zero-downtime system / Zero-downtime