Index
A
- abstraction pattern, Compilers
- admin role, Using built-in roles
- admission controllers, Points of Extensibility
- AdmissionReview type, Points of Extensibility
- aggregating ClusterRoles, Aggregating ClusterRoles
- Ambassador Ingress controller, Alternate Ingress Implementations
- annotations, Labels and Annotations, Annotations-Cleanup
- APIs
- application container images, Creating and Running Containers
- application containers, The Docker Image Format
- application-oriented container APIs, benefits of, Abstracting Your Infrastructure
- applications
- easy scaling for, Easy Scaling for Applications and Clusters
- organizing Kubernetes applications, Organizing Your Application-Summary
- code review, The Role of Code Review
- deploying your application worldwide, Deploying Your Application Around the World-Dashboards and Monitoring for Worldwide Deployments
- feature flag gates and guards, Feature Gates and Guards
- filesystem layout, Filesystem Layout
- filesystems as source of truth, Filesystems as the Source of Truth
- guiding principles, Principles to Guide Us
- managing applications in source control, Managing Your Application in Source Control
- managing releases, Managing Periodic Versions
- parameterizing applications with templates, Parameterizing Your Application with Templates
- structuring for development, testing, and deployment, Structuring Your Application for Development, Testing, and Deployment-Mapping stages to revisions
- versioning with branches and tags, Versioning with branches and tags
- versioning with directories, Versioning with directories
- real-world, deploying, Deploying Real-World Applications-Summary
- in same and different Pods, Pods in Kubernetes
- authentication, Role-Based Access Control for Kubernetes
- authorization, Role-Based Access Control for Kubernetes
- autocompletion for commands and resources, Command Autocompletion
- autoscaling, Easy Scaling for Applications and Clusters
- availability, Introduction
- az CLI tool, installing, Installing Kubernetes with Azure Kubernetes Service
- Azure Cloud Shell, Installing Kubernetes with Azure Kubernetes Service
- Azure Kubernetes Service, installing Kubernetes with, Installing Kubernetes with Azure Kubernetes Service
C
- caching, using volumes for, Cache
- cert-manager project, Serving TLS
- certificate signing request for Kubernetes API server, Points of Extensibility
- certificates
- cgroup technology (Linux kernel), Limiting Resource Usage
- change-cause annotation, Updating a Container Image, Rollout History
- CLI (command-line interface)
- clients
- cloud
- container registries for different cloud providers, Storing Images in a Remote Registry
- DNS name for databases and other services, Services Without Selectors
- infrastructure provided by, drawbacks of, Abstracting Your Infrastructure
- Ingress implementations by providers, Alternate Ingress Implementations
- installing Kubernetes on public cloud provider, Installing Kubernetes on a Public Cloud Provider-Installing Kubernetes on Amazon Web Services
- Kubernetes services, Deploying a Kubernetes Cluster
- Kubernetes-as-a-Service (KaaS) on public clouds, Separation of Concerns for Consistency and Scaling
- load-balancing capabilities by providers, Ingress Spec Versus Ingress Controllers
- LoadBalancer type, using, Cloud Integration
- storage in, Integrating Storage Solutions and Kubernetes
- using DaemonSets to install software on nodes, DaemonSets
- volume types for providers, Running a MySQL Singleton
- cloud-native applications, Introduction
- cluster IPs, The Service Object
- cluster-admin permissions, Installing Contour
- cluster-admin role, Using built-in roles
- ClusterRoleBindings, Roles and Role Bindings in Kubernetes
- ClusterRoles, Roles and Role Bindings in Kubernetes
- clusters
- autoscaling, Autoscaling a ReplicaSet
- cloud-native, DaemonSets
- components, Cluster Components-Kubernetes UI
- deploying, Deploying a Kubernetes Cluster-Running Kubernetes on Raspberry Pi
- easy scaling for, Easy Scaling for Applications and Clusters
- exploring with kubectl, The Kubernetes Client-Listing Kubernetes Worker Nodes
- listing running Pods in, Listing Pods
- MongoDB cluster creation, automating, Automating MongoDB Cluster Creation-Automating MongoDB Cluster Creation
- viewing with tools other than kubectl, Alternative Ways of Viewing Your Cluster
- CNAME records (DNS), Services Without Selectors
- code review for applications, The Role of Code Review
- command-line arguments, ConfigMap used for, Using a ConfigMap, Using a ConfigMap
- communication/synchronization, using volumes, Communication/synchronization
- compilers, Compilers
- compute costs, forecasting with Kubernetes, Easy Scaling for Applications and Clusters
- ConfigMaps, ConfigMaps and Secrets-Secrets
- creating, Creating ConfigMaps
- creating for Ghost, Configuring Ghost
- creating for Redis installation, Configuring Redis
- data values, Naming Constraints
- managing, Managing ConfigMaps and Secrets
- MongoDB ConfigMap, Automating MongoDB Cluster Creation
- naming constraints, key names for data items, Naming Constraints
- using, Using a ConfigMap
- using to add script to MongoDB image, Automating MongoDB Cluster Creation
- configurations
- container configuration file, The Docker Image Format
- declarative configuration in Kubernetes, Declarative Configuration
- declarative configuration in Pod manifests, The Pod Manifest
- for deployments, Creating Deployments
- for rolling update, Configuring a rolling update
- Ghost application, Configuring Ghost
- Ingress controller configuration, typical, HTTP Load Balancing with Ingress
- kubectl configuration file, Contexts
- managing for load balancer, HTTP Load Balancing with Ingress
- parameterizing, Parameterizing with Helm and Templates
- Redis installation, Configuring Redis
- consumers job, creating for a work queue, Creating the consumer job
- container images, Container Images-The Docker Image Format
- Container Network Interface (CNI) plug-ins, Points of Extensibility
- container registries, Container Images
- containers
- and container APIs, benefits of, Introduction
- application container images, Creating and Running Containers
- copying files to and from, Copying Files to and from Containers
- creating for Jupyter application, Jupyter
- decoupling application container image from machines, Scaling Development Teams with Microservices
- Docker runtime, The Docker Container Runtime
- existing containers, adoption by ReplicaSets, Adopting Existing Containers
- grouping in Pods, Pods
- immutable container images, The Value of Immutability
- quarantining, Quarantining Containers
- readiness checks, Readiness Probe
- resource requests per container, Resource Requests: Minimum Required Resources
- restart policy for MongoDB container, Automating MongoDB Cluster Creation
- running in a Pod, information about, Pod Details
- system and application, The Docker Image Format
- contexts, managing with kubectl, Contexts
- Contour Ingress controller, installing, Installing Contour
- controller-manager, Checking Cluster Status
- controllers for custom resources, Points of Extensibility
- core-dns server, Kubernetes DNS
- cpu-shares functionality (Linux kernel), Request limit details
- CPUs
- cron jobs
- declaring a CronJob in Kubernetes, CronJobs
- setting up to run image garbage collector, Cleanup
- curl utility, using to communicate with work queue, Loading up the queue
- custom resources, Points of Extensibility
- CustomResourceDefinition, Installing Contour, Points of Extensibility
D
- DaemonSets, Kubernetes Proxy, DaemonSets-Summary
- dashboards
- data items, specifying for ConfigMaps or secrets, Creating
- debugging, kubectl commands for, Debugging Commands-Debugging Commands, Getting More Info with Logs
- declarative configuration, The Pod Manifest
- declarative configuration objects, Declarative Configuration
- decoupled architectures, Scaling Your Service and Your Teams
- default-http-backend service, Using Hostnames
- dependencies, Optimizing Image Sizes
- deployment image, Multistage Image Builds
- Deployment object, Annotations, Deployments
- deployments, Deployments-Summary
- creating, Creating Deployments
- creating with kubectl run, The Service Object
- deleting, Deleting a Deployment
- deploying real-world applications, Deploying Real-World Applications-Summary
- deploying your application around the world, Deploying Your Application Around the World-Dashboards and Monitoring for Worldwide Deployments
- editing to add readiness check, Readiness Checks
- internal workings of, Deployment Internals-Deployment Internals
- Kubernetes deployment lifecycle, Slowing Rollouts to Ensure Service Health
- managing, Managing Deployments
- monitoring, Monitoring a Deployment
- strategies for, Deployment Strategies
- updating, Updating Deployments-Deployment Strategies
- development teams, scaling with microservices, Scaling Development Teams with Microservices
- development, structuring your application for, Goals
- directories, versioning with, Versioning with directories
- disk space on a node, getting information about, Listing Kubernetes Worker Nodes
- distributed systems, reliable and scalable, Introduction
- DNS
- Docker, Creating and Running Containers
- Docker Desktop, Kubernetes installation with, Installing Kubernetes Locally Using minikube
- Docker Hub, Storing Images in a Remote Registry
- docker images command, Cleanup
- docker login command, Storing Images in a Remote Registry
- docker rmi command, Cleanup
- docker run command
- docker system prune tool, Cleanup
- Docker-in-Docker clusters, Deploying a Kubernetes Cluster
- Dockerfiles, Dockerfiles
- .dockerignore file, Dockerfiles
- dynamic volume provisioning, Dynamic Volume Provisioning
E
- Eclipse, Alternative Ways of Viewing Your Cluster
- edit role, Using built-in roles
- editors
- efficiency provided by Kubernetes, Efficiency
- EKS (Elastic Kubernetes Service), Installing Kubernetes on Amazon Web Services
- eksctl command-line tool, Installing Kubernetes on Amazon Web Services
- elasticsearch tool, Getting More Info with Logs
- endpoints, Endpoints
- environment variables
- Envoy load balancer, Installing Contour
- etcd server, Checking Cluster Status
- events related to Pods, Pod Details
- exec probes, Types of Health Checks
- extending Kubernetes, Extending Kubernetes-Summary
- ExternalName type, Services Without Selectors
G
- garbage collection, setting up for container images, Cleanup
- gcloud tool, installing, Google Kubernetes Engine
- Ghost, Ghost-Ghost + MySQL
- GitHub
- Gloo Ingress controller, Alternate Ingress Implementations
- Google Cloud Platform, Google Kubernetes Engine
- Google Kubernetes Engine (GKE), Google Kubernetes Engine, Cloud Integration
- grace period for Pod termination, Deleting a Pod
- graceful shutdown, Readiness Checks
- groups, Identity in Kubernetes
H
- headless services, Manually Replicated MongoDB with StatefulSets
- health checks, Health Checks-Types of Health Checks
- heapster Pod, Autoscaling a ReplicaSet
- Helm, parameterizing configurations with, Parameterizing with Helm and Templates
- heptio-contour namespace, Installing Contour
- Horizontal Pod Autoscaling (HPA), Autoscaling a ReplicaSet
- horizontal vs. vertical scaling, Autoscaling a ReplicaSet
- hostnames
- hostPath volume, Mounting the host filesystem
- hosts
- HTTP health checks, Liveness Probe, Readiness Checks
- HTTP load balancing (see load balancing)
- HTTPS, webhook access via, Points of Extensibility
- hypervisors, Installing Kubernetes Locally Using minikube
I
- identity in Kubernetes, Identity in Kubernetes
- image pull secrets, Private Docker Registries
- immutability
- imperative vs. declarative configuration, Declarative Configuration, The Pod Manifest
- Informer pattern, Points of Extensibility
- infrastructure
- Ingress, Scaling Development Teams with Microservices, HTTP Load Balancing with Ingress-Summary
- IntelliJ, Alternative Ways of Viewing Your Cluster
- IP addresses
- iptables rules, kube-proxy and Cluster IPs
- Istio project, The Future of Ingress
K
- KaaS (Kubernetes-as-a-Service), Separation of Concerns for Consistency and Scaling
- kube-apiserver, --service-cluster-ip-range flag, kube-proxy and Cluster IPs
- kube-dns server, Kubernetes DNS
- kube-proxy, Kubernetes Proxy, Connecting with Other Environments
- kube-system namespace, Cluster Components, Using Hostnames
- kubeadm, Deploying a Kubernetes Cluster
- Kubebuilder project, library for Kubernetes API extensions, Getting Started
- kubectl tool, The Kubernetes Client-Listing Kubernetes Worker Nodes
- checking cluster status, Checking Cluster Status
- commands, Common kubectl Commands-Summary
- apply, Running Pods, Installing Contour, Simplest Usage, Creating a ReplicaSet, Declaratively Scaling with kubectl apply
- apply -f, Update from file
- auth can-i, Testing Authorization with can-i
- auth reconcile, Managing RBAC in Source Control
- autocompletion, Command Autocompletion
- autoscale, Autoscaling based on CPU
- contexts, Contexts
- cp, Copying Files to and from Containers
- create, Your First Deployment
- create configmap, Creating
- create secret, Creating Secrets, Creating
- create secret docker-registry, Private Docker Registries
- create secret generic, Recreate and update
- create secret tls, Serving TLS
- creating, updating, and destroying Kubernetes objects, Creating, Updating, and Destroying Kubernetes Objects
- debugging, Debugging Commands-Debugging Commands
- delete, Creating a Pod, Deleting a Pod, Deleting ReplicaSets, Deleting a Deployment, Deleting a DaemonSet
- describe, Pod Details, Looking Beyond the Cluster, Simplest Usage, Inspecting a ReplicaSet, Managing Deployments, Creating Secrets
- edit, Readiness Checks, Looking Beyond the Cluster
- edit configmap, Edit current version
- exec, Running Commands in Your Container with exec
- expose, The Service Object
- get, Creating a Pod, Listing Pods, Modifying Labels, Simplest Usage
- get clusterrolebindings, Using built-in roles
- get clusterroles, Using built-in roles
- get configmaps, Listing
- get secrets, Listing
- label, Modifying Labels, Adding Labels to Nodes
- labeling and annotating objects, Labeling and Annotating Objects
- logs, Getting More Info with Logs
- namespaces, Namespaces
- port-forward, Using Port Forwarding, The Service Object
- replace --save-config, Creating Deployments
- replace -f, Update from file, Recreate and update
- rolling-update, Deployments
- rollout, Managing Deployments, Updating a Container Image, Rolling Update of a DaemonSet
- rollout history deployment, Rollout History
- rollout pause deployments, Updating a Container Image
- rollout resume deployments, Updating a Container Image
- rollout undo deployments, Rollout History
- run, Creating a Pod
- scale, Imperative Scaling with kubectl scale, Deployment Internals
- viewing Kubernetes API objects, Viewing Kubernetes API Objects
- default-http-backend service, Using Hostnames
- getting more information via command-line flags, Listing Pods
- installing, Installing Kubernetes with Azure Kubernetes Service, Installing Kubernetes on Amazon Web Services
- listing worker nodes on a cluster, Listing Kubernetes Worker Nodes
- kubelet tool, Running Pods
- Kubernetes objects, Viewing Kubernetes API Objects, Creating, Updating, and Destroying Kubernetes Objects
- (see also objects (Kubernetes))
- kubernetes service, The Service Object
- Kubernetes-as-a-Service (KaaS), Separation of Concerns for Consistency and Scaling
- kubernetes.io/created-by annotation, Finding a ReplicaSet from a Pod
- kubernetes.io/ingress.class annotation, Running Multiple Ingress Controllers
L
- labels, Labels and Annotations-Labels in the Kubernetes Architecture
- adding to nodes, Adding Labels to Nodes
- applying, Applying Labels
- Deployment object, Deployment Internals
- external services without label selectors, Services Without Selectors
- for Kubernetes objects, using kubectl, Labeling and Annotating Objects
- for Pods managed by a ReplicaSet, Finding a Set of Pods for a ReplicaSet
- for Pods, use by ReplicaSets, Labels
- in Kubernetes architecture, Labels in the Kubernetes Architecture
- key/value pairs, rules for, Labels
- modifying, Modifying Labels
- modifying on sick Pod, Quarantining Containers
- motivations for using, Labels
- node selectors, Node Selectors
- selectors, Label Selectors, The Service Object
- using in service discovery, Manual Service Discovery
- using to run DaemonSet Pods on specific nodes, DaemonSets
- “Let's Encrypt” free certificate authority, Serving TLS
- libraries, external and shared, Creating and Running Containers
- lifecycle stages, mapping to revisions, Mapping stages to revisions
- Linkerd project, The Future of Ingress
- live updates, Live updates
- liveness probes, Liveness Probe
- load balancers
- load balancing, Scaling Development Teams with Microservices
- LoadBalancer type, Cloud Integration, HTTP Load Balancing with Ingress
- LoadTest custom resource, Points of Extensibility
- logging agent fluentd, creating on every node in target cluster, Creating DaemonSets
- logical AND, Label Selectors
- login token for Jupyter application, Jupyter
- logs
M
- machine/operating system (OS), decoupling from application container, Separation of Concerns for Consistency and Scaling
- manifests (Pod), The Pod Manifest
- master and slave replicas, Redis installation, Configuring Redis
- master nodes, Listing Kubernetes Worker Nodes
- maxSurge parameter (rolling updates), Configuring a rolling update
- maxUnavailable parameter (rolling updates), Configuring a rolling update, Rolling Update of a DaemonSet
- memory
- meta-resources, Points of Extensibility
- metadata
- labels providing metadata for objects, Labels
- metadata section in Kubernetes objects, annotation definitions in, Defining Annotations
- metadata section (Pod manifests), Creating a Pod Manifest
- microservices, Decoupling
- minikube, Deploying a Kubernetes Cluster
- minReadySeconds parameter
- mobile application, accessing Kubernetes cluster from your phone, Alternative Ways of Viewing Your Cluster
- modularity in Kubernetes, Relating Pods and ReplicaSets
- MongoDB
- multistage image builds, Multistage Image Builds
- multitenant security, Role-Based Access Control for Kubernetes
- mutable vs. immutable infrastructure, The Value of Immutability
- MutatingWebhookConfiguration, Points of Extensibility
- MySQL databases
N
- namespaces, Scaling Development Teams with Microservices, Efficiency
- network traffic, restricting in a cluster, Labels in the Kubernetes Architecture
- network-based storage, Persisting Data Using Remote Disks
- NetworkPolicy, Labels in the Kubernetes Architecture
- NewReplicaSet, Managing Deployments
- NFS persistent volume object, Running a MySQL Singleton
- NGINX ingress controller, Alternate Ingress Implementations
- NodePorts, Looking Beyond the Cluster, HTTP Load Balancing with Ingress
- nodes
- “not my monkey, not my circus” line, Separation of Concerns for Consistency and Scaling
P
- Parse application, Parse-Testing Parse
- paths
- Pending state, Listing Pods
- persistent volume claim template, Persistent Volumes and StatefulSets
- PersistentVolume, Abstracting Your Infrastructure
- PersistentVolumeClaim, Abstracting Your Infrastructure, Running a MySQL Singleton
- PersistentVolumes, Deleting a Pod
- persisting data with volumes, Persisting Data with Volumes-Putting It All Together
- Pods, Scaling Development Teams with Microservices, Pods-Summary
- accessing, Accessing Your Pod
- ConfigMaps and, ConfigMaps
- created by ReplicaSet using Pod template, Pod Templates
- creating via kubectl run command, Creating a Pod
- currently running in a cluster, listing and showing labels, Label Selectors
- currently running on a node, getting information about, Listing Kubernetes Worker Nodes
- DaemonSets determining which node Pods run on, DaemonSet Scheduler
- decoupling from DaemonSets, DaemonSet Scheduler
- deleting, Deleting a Pod
- designing, question to ask, Thinking with Pods
- example Pod with two containers and shared filesystem, Pods
- finding a ReplicaSet from, Finding a ReplicaSet from a Pod
- finding set of Pods for a ReplicaSet, Finding a Set of Pods for a ReplicaSet
- getting details about, Pod Details
- health checks, Health Checks-Types of Health Checks
- Horizontal Pod Autoscaling (HPA), Autoscaling a ReplicaSet
- imagePullSecrets spec field, Private Docker Registries
- in Kubernetes, Pods in Kubernetes
- managed by DaemonSets, deleting (or not), Deleting a DaemonSet
- managed by ReplicaSets
- manifests, The Pod Manifest
- maximum number unavailable during rolling updates, Configuring a rolling update, Rolling Update of a DaemonSet
- node selectors in Pod spec when creating DaemonSets, Node Selectors
- persisting data with volumes, Persisting Data with Volumes-Putting It All Together
- Pod template in deployment specs, Creating Deployments
- relating Pods and ReplicaSets, Relating Pods and ReplicaSets
- replicated sets of, ReplicaSets
- replicating a set of, reasons for, DaemonSets
- resource management for, Resource Management-Capping Resource Usage with Limits
- running, Running Pods
- singleton Pod running MySQL, Running a MySQL Singleton
- updating in RollingUpdate strategy, RollingUpdate Strategy
- port forwarding, The Service Object
- port-forward command (kubectl), Debugging Commands
- ports
- private container registries, Storing Images in a Remote Registry
- process health checks, Health Checks
- progressDeadlineSeconds parameter (deployments), Slowing Rollouts to Ensure Service Health, Monitoring a Deployment
- Progressing type, Monitoring a Deployment
- proxy (Kubernetes), Kubernetes Proxy
- public container registries, Storing Images in a Remote Registry
R
- Raspberry Pi
- RBAC (see role-based access control)
- rbac.authorization.kubernetes.io/autoupdate annotation, Auto-reconciliation of built-in roles
- readiness probes, Readiness Probe, Slowing Rollouts to Ensure Service Health
- reconciliation loops, ReplicaSets, DaemonSet Scheduler
- Recreate strategy, Recreate Strategy
- Redis, Redis-Playing with Our Redis Cluster
- registries (container), Creating and Running Containers
- regular expressions
- releases, progression of, Progression of a Release-Mapping stages to revisions
- reliability, Introduction
- remote disks, persisting data with, Persisting Data Using Remote Disks
- replicas (StatefulSets), Properties of StatefulSets
- ReplicaSets, The Pod Manifest, ReplicaSets-Summary
- autoscaling
- creating, Creating a ReplicaSet
- creating for MySQL singleton Pod, Running a MySQL Singleton
- creating to manage singleton work queue daemon, Starting a work queue
- deleting, Deleting ReplicaSets
- designing with, Designing with ReplicaSets
- for MongoDB, Manually Replicated MongoDB with StatefulSets
- inspecting, Inspecting a ReplicaSet
- managed by a deployment, Deployment Internals
- old and new, managed by a deployment, Updating a Container Image
- reconciliation loops, Reconciliation Loops
- relating Pods and ReplicaSets, Relating Pods and ReplicaSets
- relationship between deployments and, Deployment Internals
- scaling, Scaling ReplicaSets-Autoscaling based on CPU
- similarities with DaemonSets, DaemonSets
- specification for, ReplicaSet Spec
- resource management, Resource Management-Capping Resource Usage with Limits
- resources
- REST API, Kubernetes, Consuming Secrets
- restart policy for Pods, Liveness Probe, Automating MongoDB Cluster Creation
- revisionHistoryLimit property, Rollout History
- revisions, Rollout History
- Role object, Roles and Role Bindings in Kubernetes
- role-based access control (RBAC), Role-Based Access Control for Kubernetes-Summary
- RoleBinding object, Roles and Role Bindings in Kubernetes
- rolling updates, Deployments
- RollingUpdate strategy, RollingUpdate Strategy
- rollout commands for deployments, Managing Deployments
- rollouts
- root path (/), Using Paths
S
- scalability, Introduction
- scaling
- scheduler, Checking Cluster Status
- secrets, Secrets-Private Docker Registries
- security, Role-Based Access Control for Kubernetes
- (see also authentication; role-based access control; secrets)
- for application container images, Image Security
- selectors (label), Label Selectors, The Service Object
- self-healing systems, Self-Healing Systems
- separation of concerns, Separation of Concerns for Consistency and Scaling
- service accounts, Identity in Kubernetes
- service discovery, Service Discovery-Summary
- Service Meshes, The Future of Ingress
- Service object, Manual Service Discovery
- services
- backend, creating, Using Ingress
- creating Redis service, Creating a Redis Service
- default-http-backend, Using Hostnames
- ensuring health by slowing rollouts, Slowing Rollouts to Ensure Service Health
- exposing Ghost service, Configuring Ghost
- exposing MySQL singleton as, Running a MySQL Singleton
- hosting multiple services on paths of a single domain, Using Paths
- importing external storage services, Importing External Services-Limitations of External Services: Health Checking
- Ingress and namespaces, Ingress and Namespaces
- Kubernetes, Scaling Development Teams with Microservices
- managing multiple versions during rolling updates, Managing multiple versions of your service
- of type LoadBalancer, HTTP Load Balancing with Ingress
- (see also Ingress; LoadBalancer type)
- queue service, creating, Starting a work queue
- stateless, ReplicaSets designed for, Designing with ReplicaSets
- shutdown, graceful, Readiness Checks
- singletons
- software on a node, getting information about, Listing Kubernetes Worker Nodes
- source control
- spec for CustomResourceDefinition, Points of Extensibility
- spec for ReplicaSets, ReplicaSet Spec
- spec section (Pod manifests), Creating a Pod Manifest
- spec.type field, Looking Beyond the Cluster, Cloud Integration
- spec.volume section (Pod manifest), Using Volumes with Pods
- SSH tunneling, Looking Beyond the Cluster
- state
- StatefulSets, Kubernetes-Native Storage with StatefulSets-Summary
- status.conditions array (deployments), Monitoring a Deployment
- storage solutions, integrating with Kubernetes, Integrating Storage Solutions and Kubernetes-Summary
- StorageClass objects, Dynamic Volume Provisioning
- strategy object, Creating Deployments
- system containers, The Docker Image Format
- system daemons, deploying, DaemonSets
- system:unauthenticated group, Identity in Kubernetes
T
- tab completion for commands and resources, Command Autocompletion
- tags, source-control, Versioning with branches and tags
- TCP, HTTP Load Balancing with Ingress
- tcpSocket health checks, Types of Health Checks
- templates
- Terminating state, Deleting a Pod
- testing
- creating test environments with Kubernetes, Efficiency
- structuring your application for, Goals
- timing out a rollout, Slowing Rollouts to Ensure Service Health, Monitoring a Deployment
- TLS key and certificate, creating secret to store, Creating Secrets
- TLS, serving in Ingress system, Serving TLS
- tokens (login) for Jupyter application, Jupyter
- Traefik, Alternate Ingress Implementations
U
- UDP, HTTP Load Balancing with Ingress
- UI (Kubernetes), Kubernetes UI
- undoing rollouts, Rollout History
- update strategy, configuring for DaemonSets, Rolling Update of a DaemonSet
- updating ConfigMaps or secrets, Updating
- user accounts, Identity in Kubernetes
- UTF-8 text, ConfigMap data values, Naming Constraints
- utilization, Resource Management
V
- ValidatingWebhookConfiguration, Points of Extensibility
- validation, adding to custom resource, Points of Extensibility
- velocity in software development, Velocity
- versioning in Kubernetes, Checking Cluster Status
- vertical vs. horizontal scaling, Autoscaling a ReplicaSet
- view role, Using built-in roles
- virtual hosting, HTTP Load Balancing with Ingress
- virtualbox, Installing Kubernetes Locally Using minikube
- Visual Studio Code, Alternative Ways of Viewing Your Cluster
- volume.beta.kubernetes.io/storage-class annotation, Dynamic Volume Provisioning
- volumes, persisting data with, Persisting Data with Volumes-Putting It All Together
Y
- YAML
- deployment.yaml file, Your First Deployment, Creating Deployments
- files representing Kubernetes objects, Creating, Updating, and Destroying Kubernetes Objects
- for ConfigMap object, Creating ConfigMaps
- host-ingress.yaml file, Using Hostnames
- path-ingress.yaml file, Using Paths
- simple-ingress.yaml file, Simplest Usage
- tls-secret.yaml file, Serving TLS
..................Content has been hidden....................
You can't read the all page of ebook, please click
here login for view all page.