liveBookmanning.com

What you will learn in Kubernetes in Action, Second Edition

Deploying and managing containers and cloud-native applications

by Marko Lukša, Kevin Conner

Read it on liveBook Get the book at manning.com

Chapter by chapter

Concepts explained in this book

• Kubernetes controllerA Kubernetes controller is a control loop that observes cluster state and takes actions to move it toward a specified desired state.
• podA pod object is a Kubernetes API resource representing the desired and observed state of a pod.
• serviceA Service is a Kubernetes resource that provides a stable network endpoint for a set of application pods or manually specified destinations.
• containerA container is an isolated execution environment that packages an application process with its dependencies while sharing the host operating system kernel.
• persistent volumeA PersistentVolume is a Kubernetes API resource representing storage provisioned for use by workloads independently of a pod's lifetime.
• jobA Job is a Kubernetes resource that creates pods to run a finite task until a specified number of successful completions is reached.
• label selectorA label selector is a Kubernetes query expression that filters objects by label values or by the presence or absence of label keys.
• KubernetesA Kubernetes cluster is a group of computers running Kubernetes components that collectively manage and run containerized applications.
• ReplicaSetA ReplicaSet is a Kubernetes resource that maintains a specified number of identical pod replicas.
• Kubernetes worker nodeA Kubernetes node is a machine that runs kubelet, containers, and pods belonging to a cluster.
• DockerDocker is a platform and toolset for building, distributing, and running software containers.
• gateway apiThe Gateway API is a Kubernetes networking API standard for defining traffic gateways, listeners, and routing between external clients and cluster services.
• pod templateA pod template is a configuration embedded in a workload resource that defines the pods to be created, including their metadata and containers.
• rolling updateThe RollingUpdate strategy is a deployment update strategy that replaces application pods gradually while applying an updated pod template.
• Kubernetes APIThe Kubernetes API is the programmatic interface through which clients and applications query and modify Kubernetes resources and cluster state.
• persistent volume claimA persistentVolumeClaim volume is a pod volume definition that references a PersistentVolumeClaim by name.
• HTTPRouteAn HTTPRoute is a Kubernetes Gateway API resource that defines how HTTP requests are matched and forwarded to backend services through parent gateways.
• StatefulSetA StatefulSet is a Kubernetes resource that manages stateful pods with stable identities and ordered deployment or scaling.
• DaemonSetA DaemonSet is a Kubernetes resource that ensures a pod instance runs on each eligible node or selected subset of nodes.
• restart policyThe OnFailure restart policy directs Kubernetes to restart containers when they terminate unsuccessfully.
• ingress objectThe Ingress API is the Kubernetes API for declaring external HTTP and HTTPS access to services through ingress resources.
• linux namespaceA Linux namespace is a kernel mechanism that isolates a process's view of selected system resources from processes in other namespaces.
• volumeA volume is a storage resource that can be mounted into containers running in a pod.
• gateway objectA Gateway is a Kubernetes Gateway API resource that represents a network entry point, specifying its implementation class, listeners, and optional addresses for routing traffic.
• namespaceA namespace is a Kubernetes API resource that groups namespaced objects and provides scopes for object names and permissions within a cluster.
• kubeletThe kubelet is the agent on a Kubernetes node that manages the applications assigned to that node and reports their status.
• minReadySecondsA Kubernetes deployment setting specifying how long a newly ready pod must remain ready before it is considered available for progressing an update.
• liveness checkA liveness probe is a Kubernetes health check that determines whether a container's application is functioning and can trigger container termination after failure.
• container imageA container image is an immutable package containing a container's filesystem, application, and runtime dependencies from which containers can be created.
• dynamic provisioningDynamic provisioning is the automatic creation of persistent storage in response to a storage request rather than requiring a precreated volume.
• job controllerA Job controller is a Kubernetes controller that manages Job resources by creating and monitoring pods until the requested task completions are achieved or the Job fails.
• emptydir volumeAn emptyDir volume is a Kubernetes volume that starts empty, persists for the lifetime of its pod, and can be shared by containers in that pod.
• readiness checkA readiness endpoint is an application-provided HTTP endpoint that reports whether the application is ready to serve requests.
• init containerAn init container is a Kubernetes pod container that runs during initialization before the pod's regular containers start.
• endpoints objectA service endpoint is a network destination representing a pod that is currently eligible to receive traffic through a Kubernetes Service.
• network listenerA UDP listener is a Gateway configuration that accepts UDP traffic on a specified network port.
• Kubernetes manifestA manifest file is a YAML or JSON file that declares one or more Kubernetes objects.
• Kubernetes resourceA Kubernetes object is a persistent API resource representing a desired or observed aspect of an application or cluster.
• environment variableAn environment variable is a named value supplied through a process environment and accessible to the process and its child processes.
• labelA label is a key-value metadata attribute attached to a Kubernetes object for identifying and selecting it.
• service IPA cluster IP is the virtual network address assigned to a Kubernetes Service for receiving and forwarding traffic to its endpoints.
• canary deploymentA release technique that exposes a new application version to a limited subset of instances or traffic before expanding it broadly.
• load balancingLoad balancing is the distribution of incoming work across multiple application instances or other processing targets.
• node portA NodePort Service is a Kubernetes Service type that exposes the service through a specified port on every cluster node as well as through its cluster IP.
• post-start hookA post-start hook is a Kubernetes container lifecycle handler invoked when a container starts.
• headless serviceA headless Service is a Kubernetes Service configured to expose the addresses of its backing pods directly through DNS instead of providing a single virtual IP address.
• statusStatus is the Kubernetes object field containing information about the current observed state of the represented component or resource.
• network namespaceA network namespace is a Linux namespace that isolates network interfaces, protocol stacks, ports, and related networking resources.
• kubectl getkubectl get is a kubectl command that retrieves Kubernetes objects of a specified type from the API.
• pre-stop hookA pre-stop hook is a Kubernetes container lifecycle action executed before Kubernetes terminates the container.
• CSI driverA CSI driver is a storage plugin that implements the Container Storage Interface for provisioning and attaching storage to container workloads.
• cryptographic keyA Secret is a Kubernetes API resource for storing sensitive data such as credentials, tokens, or keys.
• sidecar processThe sidecar pattern places a complementary process in a separate container alongside a primary application process in the same pod.
• kubernetes api serverThe Kubernetes API Server is the control-plane component that validates API requests, persists Kubernetes objects, and notifies interested components of changes.
• update strategyAn update strategy is a policy that determines how a Kubernetes workload replaces running instances when its configuration changes.
• goalDesired state is a declarative description of how an application or cluster resource should be configured and operated.
• affinityNode affinity is a Kubernetes pod-scheduling rule that constrains placement to nodes matching specified node attributes.
• schedulerThe Kubernetes scheduler is the control-plane component that selects a worker node for each unscheduled application instance.
• StorageClassA StorageClass is a Kubernetes API resource that defines a category of storage, its provisioner, and parameters for dynamically creating volumes in that category.
• cronjobA CronJob controller is a Kubernetes controller that creates Jobs from a CronJob's template according to its schedule.
• ephemeral volumeAn ephemeral persistent volume is a PersistentVolume whose storage exists only for the associated workload's lifetime rather than being retained long term.
• port numberA container port is a network port on which an application in a container accepts connections.
• loadbalancer serviceThe LoadBalancer service type requests an externally accessible load balancer for a Kubernetes Service from the cluster's cloud infrastructure.
• UTS namespaceA UTS namespace is a Linux namespace that isolates the system hostname and NIS domain name visible to processes.
• IP addressAn IP address is a numeric network-layer identifier assigned to a device, network interface, or pod.
• configmapA ConfigMap is a Kubernetes API resource that stores non-confidential configuration data for use by pods or other workloads.
• SIGTERMSIGTERM is an operating-system termination signal that requests a process to shut down gracefully.
• image layerA container image layer is an independently stored filesystem change that composes a container image and can be shared across images.
• backendrefs fieldA backend reference is an HTTPRoute field entry that identifies a service or other backend to which matching traffic is forwarded.
• volume claim templateA volume claim template is a pod volume specification that defines a PersistentVolumeClaim to be created automatically for that pod.
• completion mode fieldThe completionMode field specifies how a Kubernetes Job distinguishes and counts pod completions.
• maxSurgemaxSurge is an update setting that specifies the maximum number of additional pods allowed above the desired count during a replacement update.
• maxUnavailablemaxUnavailable is an update setting that specifies the maximum number of unavailable pods permitted during a replacement update.
• Recreate strategyThe Recreate strategy is a deployment update strategy that replaces all existing application pods at once before creating the updated pods.
• access modeAn access mode is a PersistentVolume and PersistentVolumeClaim specification describing how a volume may be mounted by nodes or pods for reading and writing.
• Docker daemonThe Docker daemon is the background service that manages Docker images, containers, and container execution.
• ingress controllerAn ingress controller is a Kubernetes controller that implements external HTTP or HTTPS traffic routing defined by Ingress objects.
• indexed completion modeIndexed completion mode assigns each Job pod a distinct zero-based completion index that identifies the portion of work it should process.
• scalabilityHorizontal scaling is the addition or removal of application instances to adjust capacity to changing workload levels.
• eventA Kubernetes Event is an API object that records an occurrence or state transition involving a cluster object.
• replica countA desired replica count is the configured number of pod replicas that a workload resource should maintain.
• pid namespaceA PID namespace is a Linux isolation scope that gives processes an isolated view of process identifiers and process hierarchy.
• pod management policyA pod management policy is a StatefulSet setting that controls whether pods are created sequentially or concurrently during management operations.
• kubectlkubectl is the Kubernetes command-line client for submitting requests to and managing resources through the Kubernetes API.
• local volumeA local volume is a Kubernetes volume type that exposes storage attached to a specific node and constrains pod scheduling to that node.
• operating system kernelA kernel is the privileged core of an operating system that manages hardware resources and executes system-level operations.
• custom resource definitionA CustomResourceDefinition is a Kubernetes API object that extends the Kubernetes API with a new custom resource type.
• node selectorA node selector is a pod scheduling constraint that restricts placement to nodes whose labels match specified criteria.
• specA spec is the Kubernetes object field containing the declarative configuration of the desired state.
• OnDelete update strategyA Kubernetes StatefulSet update strategy that applies a new pod template only when an existing pod is manually deleted.
• exec lifecycle hookAn exec lifecycle hook runs a command or process inside a container at a configured lifecycle event.
• http get lifecycle hookAn HTTP GET lifecycle hook sends an HTTP GET request to a specified host, port, and path at a configured container lifecycle event.
• ingress routing ruleAn ingress rule is a rule in an Ingress object that maps a host and path match to a destination service and port.
• mount pointVolumeMounts is the Kubernetes container field containing the volume mount definitions for that container.
• static provisioningStatic provisioning is the administrator-managed creation of storage volumes and corresponding PersistentVolume objects before workloads claim them.
• termination grace periodThe terminationGracePeriodSeconds field specifies the default number of seconds Kubernetes allows a pod's containers to terminate gracefully.
• Docker DesktopDocker Desktop is a desktop application that packages Docker components and provides a local environment for running containers on supported operating systems.
• kubectl rollout statuskubectl rollout status is a kubectl command that reports the progress and completion status of a resource rollout.
• volume binding modeA volume binding mode is a StorageClass setting that determines when a PersistentVolume is bound to a PersistentVolumeClaim.
• primary containerA regular container is a pod container that runs after all init containers have completed.
• completion indexThe job completion index annotation is pod metadata containing the completion index assigned by an indexed Kubernetes Job.
• session affinityCookie-based session affinity is a traffic-routing policy that uses an HTTP cookie to keep a client associated with the same backend instance.
• CrashLoopBackOffCrashLoopBackOff is a Kubernetes container state reason indicating repeated termination and a waiting period before the next restart.
• statefulnessA stateful backend is a backend application component whose operation depends on retained application or client state.
• endpoint sliceAn EndpointSlice is a Kubernetes API resource that represents a scalable set of network endpoints for a Service and their associated metadata.
• kubectl port-forwardkubectl port-forward is a kubectl operation that forwards traffic from a local port to a port on a Kubernetes resource such as a pod.
• replicaAn application instance is a running replica of an application managed by Kubernetes.
• env fieldThe env field is a Kubernetes container specification field containing individually defined environment variable name–value entries.
• projected volumeA projected volume is a Kubernetes volume that combines data from multiple sources, such as ConfigMaps, Secrets, and the Downward API, into one mounted directory.
• kubectl describekubectl describe is a kubectl command that displays detailed information about a Kubernetes object and related cluster information.
• ReadWriteOncePodReadWriteOncePod is a Kubernetes volume access mode that permits a volume to be mounted read-write by only one pod at a time.
• equality-based label selectorAn equality-based label selector filters objects by requiring a label value to equal or not equal a specified value.
• set-based label selectorA set-based label selector filters objects by testing label values or label-key presence against specified sets or existence conditions.
• image volumeAn image volume is a Kubernetes volume that exposes the files from an OCI image to containers in the same pod, typically as read-only content.
• lifecycle methodA lifecycle hook is a Kubernetes container configuration that triggers an action at a defined point in the container lifecycle.
• downward apiA downwardAPI volume is a Kubernetes volume source that projects selected pod or container metadata and resource information into files in a container.
• owner referenceThe ownerReferences field is Kubernetes object metadata that identifies the objects responsible for managing the object.
• versionAn API version identifies a versioned Kubernetes API schema for a resource kind, including its available fields and default values.
• hostpath volumeA hostPath is a Kubernetes volume type that mounts a file or directory from a worker node into a pod.
• kubectl logskubectl logs is a Kubernetes command-line operation that retrieves output streams captured from a container.
• CoreDNSCoreDNS is an extensible DNS server commonly deployed in Kubernetes clusters to provide service and pod name resolution.
• dns policyA Kubernetes DNS policy specifies how a pod obtains and prioritizes DNS configuration.
• DNS serverA DNS server resolves domain names into network addresses and other DNS records.
• startup probeA startup probe is a Kubernetes container health check that determines when a slow-starting application has initialized sufficiently for other probes to begin operating.
• container auto-restartA container restart is the termination and subsequent creation or execution of a replacement instance of a container by its runtime or orchestrator.
• MongoDB replica setA MongoDB replica set is a group of MongoDB server instances that maintain replicated data and designate a primary for write operations.
• http get probeAn httpGet probe is a Kubernetes container probe that sends an HTTP GET request to determine the application state.
• DaemonSet controllerA DaemonSet controller is the Kubernetes controller that reconciles a DaemonSet by creating and managing its pods across eligible nodes.
• tolerationA toleration is a pod scheduling specification that permits a pod to be scheduled onto a node with a matching taint.
• kubectl rollout undokubectl rollout undo is a kubectl command that reverts a Kubernetes workload to an earlier recorded revision.
• kubectl explainkubectl explain is a Kubernetes command that displays documentation for the fields and structure of an API object type.
• clusterip service typeA ClusterIP service is a Kubernetes Service that provides an internal cluster IP address for reaching a set of pods.
• schedulingScheduling is the process of selecting suitable compute nodes on which workloads should run.
• IstioIstio is an open-source service mesh platform that provides traffic management, security, and observability for services.
• crontab formatThe schedule field specifies the recurring time expression that determines when a CronJob creates Jobs.
• virtual machineA virtual machine is a software-emulated computer that runs an operating system and applications in an isolated environment.
• parallelism fieldThe parallelism field is a Job specification field that limits the number of pods allowed to run concurrently for the Job.
• suspend fieldThe suspend field is a Kubernetes Job specification field that controls whether execution of the Job is suspended.
• ttlSecondsAfterFinished fieldThe ttlSecondsAfterFinished field is a Kubernetes Job specification field that defines how long a finished Job and its pods are retained before automatic deletion.
• configmap volumeA ConfigMap volume is a Kubernetes volume that exposes data from a ConfigMap as files mounted in a container.
• kube-proxykube-proxy is a Kubernetes node component that implements network connectivity and load balancing for services and their application endpoints.
• servlet filterA Gateway API filter is a route-rule operation that modifies, mirrors, or otherwise processes requests and responses.
• exec probeAn exec probe is a Kubernetes liveness-check mechanism that runs a command inside a container and succeeds when the command exits with code zero before its timeout.
• reverse proxyA reverse proxy is a server-side intermediary that receives client requests and forwards them to backend applications or services.
• kubectl get --rawkubectl get --raw is a kubectl command that sends a raw request to a URI through the Kubernetes API server.
• Kubernetes network modelThe Kubernetes network model is the networking design in which pods can reach one another and nodes can reach pods across the cluster.
• loopback interfaceA loopback device is a network interface that routes traffic within the same host or network namespace without sending it through an external network.
• SRV recordAn SRV record is a DNS record that identifies the host and port for a service, along with its protocol and priority information.
• kubectl expose deploymentkubectl expose is a Kubernetes command that creates a Service for an existing workload or pod.
• secret data fieldThe stringData field is a Secret field that accepts plain-text key-value data and is converted into the data field when stored.
• symbolic linkA symbolic link is a filesystem object that refers to another filesystem path rather than containing the target data itself.
• KindKind is a tool for running local Kubernetes clusters using Docker containers as nodes.
• container registryA container registry is a repository service that stores and distributes container images to authorized clients.
• Base64Base64 encoding represents binary or textual data as printable characters without providing confidentiality.
• conditionA condition is a status entry representing one aspect of a Kubernetes object's current state.
• imperative programmingAn imperative command directly instructs a system to perform a specified operation.
• cgroupA cgroup is a Linux kernel mechanism that groups processes and limits, accounts for, and isolates their use of resources such as CPU, memory, and bandwidth.
• DockerfileA Dockerfile is a text configuration file containing instructions for building a Docker container image.
• leader electionLeader election is a coordination mechanism that selects one instance as active leader while other instances remain ready to take over after failure.
• self-healing mechanismA self-healing system automatically detects or tolerates failures and restores affected workloads or services without requiring immediate manual intervention.
• service discoveryService discovery is a mechanism by which applications locate other applications or services and obtain the information needed to use them.
• file systemA filesystem is a structure and set of operations for organizing, storing, and accessing files, including the isolated filesystem presented to a container.
• work queue patternA work queue is a collection of pending work items from which workers retrieve tasks for processing.
• TLS terminationTLS termination is the process of ending a TLS connection at an intermediary, such as a reverse proxy, so that subsequent traffic can be handled as plaintext or re-encrypted.
• managed Kubernetes serviceA managed Kubernetes cluster is a Kubernetes cluster whose control-plane operation and underlying infrastructure are operated by a service provider.
• service meshA service mesh is an infrastructure layer that manages communication, observability, traffic, and security between services without requiring application code changes.
• Linux capabilityA Linux capability is a fine-grained kernel privilege that grants a process permission to perform selected operations otherwise restricted by kernel checks.
• internal traffic policyInternal traffic policy is a Kubernetes Service setting that restricts traffic from a client pod to service endpoints on the same node when configured for Local routing.
• reclaim policyThe reclaimPolicy field is a StorageClass configuration field that sets the reclaim policy for provisioned PersistentVolumes.
• Kubernetes EngineGKE is Google Cloud's managed Kubernetes service for running Kubernetes clusters.
• system callA system call is an interface through which a user-space process requests services or operations from the operating system kernel.
• mount namespaceA mount namespace is a Linux namespace that isolates the filesystem mount points visible to processes.
• annotationAn annotation is a key-value metadata attribute attached to a Kubernetes object for storing non-identifying information.
• ready conditionContainer readiness is the status indicating whether a container is ready to serve its intended workload.
• control planeA control plane is the cluster-management component that makes decisions about and controls the operation of worker resources.
• waitforfirstconsumerWaitForFirstConsumer is a volume-binding policy that delays persistent-volume binding and provisioning until a pod using the claim is created.
• coarse parallel processingCoarse parallel processing assigns one work item to each pod, with each pod terminating after processing that item.
• fine parallel processingFine parallel processing assigns multiple work items sequentially to each of a small number of pods that process items concurrently.
• kubectl rollout historykubectl rollout history is a kubectl command that displays the recorded revisions of a Kubernetes workload.
• copy-on-writeA copy-on-write mechanism preserves shared data until a modification causes a private copy to be created.
• privileged containerA privileged container is a container whose processes receive unrestricted or nearly unrestricted access to the host kernel's operations.
• Docker CLIThe Docker CLI is the command-line client for sending container-management commands to Docker.
• image tagAn image tag is a human-readable label appended to a container image name to identify a particular image reference or version.
• base imageA base image is a container image selected as the starting point for building another container image.
• build contextA build context is the set of files and directories supplied to Docker for building a container image.
• Dockerfile instructionA Dockerfile instruction is a declarative command that specifies one step in building a container image.
• gateway api implementationA Gateway API implementation is software installed in a Kubernetes cluster that realizes Gateway API resources and provisions the traffic proxies they require.
• state persistenceData persistence is the preservation of data so that it remains available across process or container termination and recreation.
• native sidecarA native sidecar is a Kubernetes container configured as an init container with restartPolicy set to Always, giving it sidecar lifecycle ordering and restart behavior.
• pathType fieldThe pathType field specifies the matching semantics applied to a request path in an Ingress rule.
• kubectl applykubectl apply is a kubectl command that creates or updates Kubernetes objects from a manifest file or set of manifest files.
• at-most-one semanticsAt-most-one semantics guarantee that no more than one pod with a given identity runs concurrently.
• network-attached volumeA network-attached volume is storage exposed over the network so it can potentially be detached from one node and attached to another.
• ordinal-based naming schemeAn ordinal-based naming scheme assigns sequential ordinal identifiers to related pods to provide stable names and identities.
• pod identityA pod identity is the stable name-based identity that distinguishes a StatefulSet pod from other pod instances.
• passthroughTLS passthrough is a traffic-handling technique in which an ingress component forwards encrypted TLS connections to a backend instead of terminating TLS itself.
• label selector operatorA label selector operator defines how a selector compares a label key and its values, including equality, set membership, existence, and numeric comparison.
• match expressionA match expression is a Kubernetes node-affinity condition consisting of a label key, an operator, and optional values for specifying node label requirements.
• node agentA node agent is a node-local software component that exposes system information to client applications over a network protocol.
• mountpathMountPath is a Kubernetes container volume-mount field that specifies the path where a volume is mounted in the container filesystem.
• tmpfstmpfs is a memory-backed filesystem whose stored contents reside in volatile memory.
• hostPortA Kubernetes container port field that exposes a container port through a network port on the hosting node while the pod retains its own network.
• kind fieldAn object kind is the Kubernetes API identifier that specifies the type of an API object.
• network isolationNetwork isolation is the restriction of network communication so that a pod can communicate only with explicitly permitted pods.
• MinikubeMinikube is a tool for running a local Kubernetes cluster, typically using a virtual machine or containers as the cluster environment.
• last-applied-configuration annotationThe last-applied-configuration annotation is a Kubernetes object annotation that stores the configuration last applied by kubectl for comparison during subsequent applies.
• TCP socket probeA TCP socket probe is a Kubernetes container probe that checks whether a TCP connection can be established on a specified port.
• dual-stack networkingDual-stack networking provides simultaneous IPv4 and IPv6 connectivity within a network environment.
• kubectl set selectorkubectl set selector is a kubectl command that changes the label selector of a Kubernetes resource.
• targetport fieldThe targetPort field specifies the port on selected pods to which a Kubernetes Service forwards traffic.
• subdomain fieldThe subdomain field is a Kubernetes pod specification field that supplies the subdomain used in the pod's internal DNS name.
• data sourceA data source is an origin object from which a newly provisioned PersistentVolume is initialized with data.
• readonlymanyReadOnlyMany is a Kubernetes volume access mode that permits a volume to be mounted read-only by multiple nodes or pods concurrently.
• readwritemanyReadWriteMany is a Kubernetes volume access mode that permits a volume to be attached read-write concurrently to multiple nodes.
• readwriteonceReadWriteOnce is a Kubernetes volume access mode that permits a volume to be attached read-write to one node, while multiple pods on that node may use it.
• TLS secretA TLS Secret is a Kubernetes Secret intended to store a TLS certificate and its corresponding private key.
• volume cloningVolume cloning is the creation of a new PersistentVolume initialized from an existing PersistentVolume or its PersistentVolumeClaim.
• exponential backoffExponential backoff is a retry strategy that progressively increases the delay between successive attempts, subject to a maximum and reset conditions.
• kubectl patchkubectl patch is a Kubernetes command that updates selected fields of a Kubernetes object without replacing its entire manifest.
• kubectl set imagekubectl set image is a kubectl command that changes the container image used by containers in Kubernetes resources.
• ingressclassAn IngressClass is a Kubernetes API resource that identifies the ingress controller responsible for processing Ingress objects and can provide controller parameters.
• terminatingTerminating is a Kubernetes lifecycle status indicating that an object has been marked for deletion but has not yet been fully removed.
• gatewayclassA GatewayClass is a Kubernetes Gateway API resource that defines a class of gateways managed by a particular controller and optionally associated parameters.
• reconciliationA reconciliation loop is a repeated control process that compares observed state with desired state and makes corrective changes.
• Kubernetes operatorA Kubernetes Operator is a controller pattern that automates the management of a specialized application or workload by encoding operational knowledge.
• virtual hostingVirtual hosting is a technique that routes requests to different backends based on the requested host name.
• schemaA schema is a formal description of the fields and structure used to represent an object.
• horizontal scalingScaling out is increasing application capacity by running additional application instances.
• envfrom fieldThe envFrom field is a Kubernetes container specification field that imports key-value entries from a referenced configuration source as environment variables.
• microservice architectureA microservice architecture structures an application as multiple independently deployable services that collaborate through defined interfaces.
• kubectl scale deploymentkubectl scale is a kubectl command that changes the number of replicas maintained by a scalable Kubernetes resource.
• logical viewA logical view is an abstraction of an application that represents its Kubernetes objects and relationships without exposing the underlying infrastructure.
• rollbackA rollback is the reversion of a deployed application workload to an earlier version or revision.
• field selectorA field selector is a Kubernetes API query mechanism that filters objects by matching specified field values.
• hypervisorA hypervisor is software that creates and manages virtual machines by allocating physical hardware resources to them.
• Kubernetes-as-a-ServiceKubernetes-as-a-Service is a cloud service model in which a provider operates the Kubernetes control plane and related infrastructure for users.
• termination stageThe termination stage is the pod lifecycle stage in which its containers are shut down after the Pod object is deleted.
• exec formThe exec form is Dockerfile syntax that invokes an ENTRYPOINT or CMD executable directly without starting a shell.
• graceful shutdownA graceful shutdown is an orderly termination procedure that stops accepting new work and allows in-progress work to complete before exit.
• shell formThe shell form is Dockerfile syntax that runs an ENTRYPOINT or CMD instruction through a shell.
• externalname service typeAn ExternalName service is a Kubernetes Service whose DNS name is an alias for an external DNS name specified by its externalName field.
• data planeThe workload plane is the collection of worker resources on which applications run in a cluster.
• pod phaseA pod phase is a high-level Kubernetes status value summarizing the pod's current lifecycle stage.
• kubectl editkubectl edit is a Kubernetes command that interactively modifies a Kubernetes object definition through the Kubernetes API.
• resourceAn API resource is an addressable Kubernetes API endpoint and representation associated with an object type.
• exit codeAn exit code is a numeric result returned by a process when it terminates, conventionally indicating success or failure.
• job templateA Job template is the configuration embedded in a CronJob that defines the Jobs it creates.
• inline file contentInline file content is data embedded directly in a pod manifest to be written into a mounted volume as a file.
• secret volumeA secret volume is a Kubernetes volume that exposes Secret data as files mounted in containers running in a pod.
• pod availabilityPod availability is the state in which a pod has remained ready for the required minimum duration and can count toward a workload's available replicas.
• progress deadline secondsThe progressDeadlineSeconds field specifies the maximum time a Deployment may fail to make progress before its rollout is reported as stalled.
• progressing conditionA progressing condition is a Deployment status condition that reports whether progress is being made toward completing an update.
• inter-process communication namespaceAn IPC namespace is a Linux isolation scope that separates a process's inter-process communication resources from those of processes outside the namespace.
• subpathSubPath is a Kubernetes volume-mount field that selects a file or subdirectory within a volume for mounting.
• core featureA core feature is a portable Gateway API feature that every conforming implementation must support.
• entrypoint instructionThe ENTRYPOINT instruction specifies the executable command that runs when a container starts.
• experimental release channelThe experimental release channel contains Gateway API resources and fields that may change in future API versions.
• extended featureAn extended feature is a portable Gateway API feature whose behavior is consistent across implementations that support it but that is not required of every implementation.
• implementation-specific featureAn implementation-specific feature is a Gateway API feature whose availability, behavior, or semantics depend on a particular implementation.
• standard release channelThe standard release channel contains Gateway API resources and fields considered stable and not expected to change in future API versions.
• support levelA support level classifies how consistently a Gateway API feature is supported across implementations.
• AppArmorAppArmor is a Linux security mechanism that enforces mandatory access control using path-based profiles for processes.
• container recreationContainer recreation is the replacement of a terminated container by discarding it and creating a new container.
• seccompseccomp is a Linux kernel security facility that restricts the system calls a process may invoke.
• SELinuxSELinux is a Linux security mechanism that enforces mandatory access control through labels and policy rules.
• peer discoveryPeer discovery is the process by which members of a distributed application locate and communicate with one another.
• deployment revisionA Deployment revision is a versioned record of a Deployment's pod template and rollout state represented by an associated ReplicaSet.
• kubectl rollout restartkubectl rollout restart is a kubectl command that recreates the pods managed by a workload resource.
• revision history limit fieldThe revision history limit field specifies how many old ReplicaSets a Deployment retains for rollback and inspection.
• metadata sectionA metadata section is the part of a Kubernetes object definition containing identity and management metadata for an object instance.
• monitoringA log file is a file containing records of events and diagnostic messages emitted by a process or application.
• volumesnapshotA volume snapshot artifact is a point-in-time copy of data stored on a persistent volume.
• claimrefclaimRef is the PersistentVolume specification field that records the PersistentVolumeClaim to which the volume is associated.
• released statusReleased is a PersistentVolume status indicating that its previous claim has been deleted while the volume may still contain data requiring administrator handling.
• retain policyThe Retain policy preserves a PersistentVolume and its underlying storage after the associated claim is deleted or released.
• underlying storageUnderlying storage is the physical, virtual, or cloud-backed storage resource represented or accessed by a PersistentVolume.
• storageclassnameThe storageClassName field is the PersistentVolumeClaim field that selects the StorageClass from which its requested persistent storage should be provisioned.
• standard outputStandard output is the conventional output stream through which a process writes ordinary textual results.
• metadataMetadata is the Kubernetes object information describing an object, including identity, labels, annotations, and related attributes.
• authorizationA file permission is an access right specifying whether a user class may read, write, or execute a filesystem object.
• fsgroup fieldThe fsGroup field is a Kubernetes pod security-context field that assigns a supplemental group and can set group ownership for mounted volume files.
• group ownershipGroup ownership is the association of a filesystem object with a Unix user group whose permissions can govern access to it.
• stable addressA stable address is a network address that remains associated with a workload identity when its underlying pod is replaced or relocated.
• kubectl execkubectl exec is a kubectl command that executes a command inside a running container in a pod.
• kube-api-access volumeThe kube-api-access volume is a built-in projected volume that provides a pod with credentials and cluster information for accessing the Kubernetes API.
• declarative programmingA declarative model specifies the desired state of a system while leaving the system responsible for determining and performing the operations needed to achieve it.
• kubectl deletekubectl delete is a kubectl command that removes Kubernetes objects identified by names, manifest files, or other selectors.
• client dry runA client dry run is a command mode that renders the requested object locally without creating it through the API.
• TLSRouteA TLSRoute is a Kubernetes Gateway API resource that routes TLS traffic to backend services using information available from the encrypted connection, primarily the recipient hostname.
• weightA weight is a routing value that determines a backend's proportional share of requests relative to the weights of other backends.
• default backendThe defaultBackend field is an Ingress specification field that identifies the fallback backend for unmatched requests.
• resource utilizationInfrastructure utilization is the proportion of available computing resources that are actively used by workloads.
• volume modeVolume mode is a PersistentVolumeClaim specification that selects filesystem or raw-block presentation for the requested storage.
• image pull policyAn image pull policy is a Kubernetes container setting that determines when its container image is pulled onto a node.
• MongoDBCommunityA custom Kubernetes API object type representing the desired configuration of a MongoDB Community deployment managed by an operator.
• docker registry secretA Docker registry Secret is a Kubernetes Secret containing credentials that allow workloads to pull images from a private container registry.
• imagePullSecrets fieldThe imagePullSecrets field in a pod specification lists Secrets containing credentials for authenticating to container registries.
• kubectl create secretkubectl create secret is a kubectl command for creating Kubernetes Secret resources from command-line inputs or files.
• opaque secretAn opaque Secret is a generic Kubernetes Secret whose data has no specialized built-in interpretation.
• namespace objectA namespace object is a Kubernetes API resource representing a namespace and its lifecycle state.

These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.