Kubernetes: Networking & Storage: glossary
160 terms, in plain words, with where each one is taught.
- 308 Permanent Redirect (ssl-redirect)
- An HTTP answer "go to this other URL from now on" that keeps the method (a POST stays a POST). ingress-nginx sends it from http to https once a host has TLS. Lesson 18.22
- access mode (accessModes, ACCESS MODES)
- How a volume may be mounted: RWO (one node), ROX (read-only, many nodes), RWX (read-write, many nodes), RWOP (one pod). Lesson 18.41
- AdminNetworkPolicy (BaselineAdminNetworkPolicy)
- Newer cluster-wide policies with real deny rules and priorities, for platform-wide guardrails. Lesson 18.31
- agnhost
- A small test program from the Kubernetes project; with netexec it is a web server that answers /hostname and /clientip. The labs use it as the app behind Services. Lesson 18.1
- allowedRoutes
- A Gateway listener setting: routes from which namespaces may attach (Same, All, or those matching a label selector). Lesson 18.26
- allowedTopologies
- A StorageClass setting that limits which zones it may create volumes in. Lesson 18.41
- autopath
- A CoreDNS plugin that works out the right name on the first query from a pod, saving the search-list misses. Needs "pods verified". Lesson 18.14
- backendRefs
- The HTTPRoute field listing the Services and ports a rule sends traffic to, each with an optional weight. Lesson 18.26
- bare metal
- Running on your own machines (or plain VMs) instead of a cloud provider, so nothing creates cloud load balancers or disks for you. Lesson 18.6
- BGP
- The protocol routers use to tell each other which address ranges they can reach. Calico's per-node agents use it to share pod blocks. Lesson 18.35
- binding (Bound)
- Linking one claim to one PersistentVolume, exclusively. A claim binds only if class, access modes, size and volume mode all match. Lesson 18.39
- BIRD
- A routing program. Calico runs it on every node to tell the other nodes which pod addresses live there;
ip routemarks those routesproto bird. Lesson 18.35 - blackhole route (blackhole)
- A route that throws matching packets away, so addresses that should not exist fail fast. Lesson 18.35
- block storage
- A raw disk device attached to one machine, which puts its own filesystem on it (cloud disks, Ceph RBD). Supports RWO/RWOP only. Lesson 18.41
- Ceph
- Open-source storage cluster software that offers disks (RBD) and shared filesystems (CephFS) over the network. Lesson 18.39
- cert-manager
- A controller you install that gets certificates from a certificate authority, writes them into TLS Secrets and renews them before they expire. Lesson 18.22
- claimRef
- The field on a PV naming the claim bound to it (including that claim's uid). Lesson 18.39
- cluster domain (cluster.local, clusterDomain)
- The DNS suffix every in-cluster name ends in, cluster.local by default. The kubelet writes it into every pod's search list. Lesson 18.13
- ClusterIP (cluster IP, CLUSTER-IP)
- The stable virtual IP a Service gets, reachable only from inside the cluster. No machine owns it: rules on every node rewrite packets sent to it. Also the name of the default Service type. Lesson 18.1
- CNI plugin (CNI plugins)
- The program that gives each pod its network interface and IP and makes pod IPs reachable between nodes. It also enforces NetworkPolicies (if it supports them). Lesson 18.29
- conntrack (connection tracking)
- The kernel's table of open connections with their original and rewritten addresses, so every packet of a connection is rewritten the same way. This is why a connection sticks to one pod.
conntrack -L -d IPlists the entries going to an address. Lesson 18.3 - cordon (uncordon, SchedulingDisabled, unschedulable)
- Marking a node "no new pods" (kubectl cordon); uncordon allows them again. Pods already there keep running. Lesson 18.41
- CoreDNS plugin (plugin)
- One feature of CoreDNS, turned on by one line in a server block: kubernetes, forward, cache, log, reload, errors, health... Lesson 18.13
- Corefile
- CoreDNS's configuration file: server blocks, each with a list of plugins. On a cluster it lives in the ConfigMap coredns in kube-system. Lesson 18.13
- CSI (Container Storage Interface, CSI driver)
- Container Storage Interface: the standard plugin interface between Kubernetes and storage systems. A CSI driver is a controller Deployment plus a per-node DaemonSet. Lesson 18.39
- dash trap (AND vs OR)
- In a NetworkPolicy, namespaceSelector and podSelector under one dash are one peer (both must match, AND); under two dashes they are two peers (either matches, OR). Lesson 18.31
- default backend (default server, upstream-default-backend)
- What an Ingress controller answers when no rule matches - with ingress-nginx, a plain 404 page. Lesson 18.19
- default deny (default-deny)
- A NetworkPolicy that selects every pod in a namespace (podSelector {}) and allows nothing, so only what later policies allow gets through. Lesson 18.29
- default IngressClass (is-default-class)
- An IngressClass with the is-default-class annotation. Its name is filled into new Ingresses that name no class - only at creation. Lesson 18.19
- default StorageClass (is-default-class)
- The class with the storageclass.kubernetes.io/is-default-class annotation, filled into every claim that names no class. Lesson 18.39
- DNAT (destination NAT)
- NAT that changes where a packet is going. kube-proxy uses it to turn "to the ClusterIP" into "to this pod IP and port". Lesson 18.3
- dnsConfig
- A pod setting that adds nameservers or search domains, or overrides options like ndots, on top of what dnsPolicy generates. Lesson 18.13
- dnsPolicy (ClusterFirst, ClusterFirstWithHostNet)
- A pod setting that decides its resolv.conf: ClusterFirst (the default: cluster DNS), Default (the node's resolver, despite the name), ClusterFirstWithHostNet, or None. Lesson 18.13
- dynamic provisioning
- You create only the claim; the StorageClass's provisioner creates a matching volume for it. Lesson 18.39
- eBPF
- Small programs loaded into the Linux kernel that can handle packets directly. Some network plugins use it to replace kube-proxy's iptables rules. Lesson 18.3
- egress gateway
- One fixed proxy that all outbound traffic must pass through, so outside firewalls can allow a single address. Lesson 18.31
- egress rule (egress)
- In a NetworkPolicy, a rule for outgoing traffic from the selected pods (to these peers, on these ports). Lesson 18.29
- Endpoints object
- The older, one-per-Service list of pod IP:port pairs behind a Service. Still written for compatibility; EndpointSlice replaced it. Lesson 18.1
- EndpointSlice (EndpointSlices, endpointslice)
- The object that lists the pod IPs and ports currently behind a Service, with a ready flag for each. A controller keeps it up to date; kube-proxy routes from it. Find a Service's slices with
kubectl get endpointslice -l kubernetes.io/service-name=NAME. Lesson 18.1 - eviction (evicted)
- The kubelet stopping a pod and removing it from its node, for example when the pod uses more local disk than allowed. Lesson 18.37
- EXTERNAL-IP
- The column of
kubectl get svcshowing the address outside clients use for a LoadBalancer Service; <pending> while nobody has provided one, <none> for internal types. Lesson 18.6 - ExternalName
- A Service type that is only a DNS alias: its name returns a CNAME to an outside name. No IP, no ports, no proxying. Lesson 18.6
- externalTrafficPolicy (externalTrafficPolicy: Local)
- Where outside traffic may go. Cluster (default): any pod, possibly on another node, with the client IP rewritten. Local: only pods on the receiving node, keeping the client IP; nodes without one drop it. Lesson 18.6
- Fake Certificate (Kubernetes Ingress Controller Fake Certificate)
- The self-signed certificate ingress-nginx serves when it has no usable certificate for the requested name. Seeing it means the TLS Secret is missing or wrong. Lesson 18.22
- file storage (shared file storage, file share)
- A filesystem served over the network that many machines mount at once (NFS, CephFS, cloud file shares). Can do RWX. Lesson 18.41
- FileSystemResizePending
- A claim condition: the volume has grown but the filesystem on it not yet; the kubelet finishes it on the node where it is mounted. Lesson 18.44
- Flannel
- A simple CNI plugin that builds a VXLAN overlay. It does not enforce NetworkPolicy: policies are stored and silently ignored. Lesson 18.29
- forward plugin (forward)
- The CoreDNS plugin that sends names it does not know to an upstream DNS server (by default the node's own resolvers). Lesson 18.13
- Gateway
- A Gateway API object that is an actual entry point: its listeners (port, protocol, hostname, TLS) and which namespaces may attach routes. Lesson 18.26
- Gateway API
- The newer official Kubernetes API for traffic entry, successor to Ingress: GatewayClass, Gateway and HTTPRoute, each owned by a different team, with typed fields and detailed status. Lesson 18.26
- GatewayClass
- A cluster-wide Gateway API object: "gateways of this kind are run by that controller" - the role IngressClass plays for Ingress. Lesson 18.26
- getent hosts
- Looks a name up exactly the way applications do, through the C library resolver with the search list and /etc/hosts. Lesson 18.13
- gratuitous ARP
- An ARP reply nobody asked for, telling every neighbour "this IP is at my MAC now" - used when an IP moves to another machine.
- hairpin (hairpin NAT)
- A pod reaching itself through its own Service. The kernel needs an extra rewrite so the reply finds its way back. Lesson 18.3
- healthCheckNodePort
- A port a LoadBalancer Service with externalTrafficPolicy Local opens so the external balancer can check which nodes have a pod to send to. Lesson 18.6
- hostAliases
- A pod setting that adds lines to the pod's /etc/hosts - fixed name to IP entries. Lesson 18.13
- hostNetwork
- A pod setting to use the node's network directly instead of its own, like Docker's --network host. Lesson 18.13
- hostPath
- A volume that mounts a directory of the node into the pod. Data stays on that one node, and it gives the pod access to the node - dangerous for applications. Lesson 18.37
- hostPort
- A pod setting that opens one of its ports on the node's IP, like Docker's -p (done by the portmap CNI plugin). Lesson 18.35
- HTTPRoute
- A Gateway API object with an app's HTTP routing rules: hostnames, matches (path, headers...), filters, and weighted backends. Lesson 18.26
- Ingress (Ingresses, ingress resource)
- A Kubernetes object that describes HTTP(S) routing: requests for this host and path go to that Service. It does nothing until an Ingress controller reads it. Lesson 18.19
- Ingress controller (ingress controller)
- A reverse proxy running in the cluster (a Deployment you install) that watches Ingress objects and routes HTTP traffic according to them. Lesson 18.19
- Ingress rule (host rule, path rule)
- One entry of an Ingress: a host (from the Host header) and a list of paths, each sent to a backend Service and port. Lesson 18.19
- ingress rule (ingress (NetworkPolicy))
- In a NetworkPolicy, a rule for incoming traffic to the selected pods (from these peers, on these ports). Not the same thing as the Ingress object. Lesson 18.29
- ingress-nginx
- A widely used Ingress controller built on nginx. The project was retired in 2026 (no more fixes), though many clusters still run it. Lesson 18.19
- IngressClass
- A cluster object naming a class of Ingress (like nginx) and the controller that serves it. An Ingress picks one with ingressClassName. Lesson 18.19
- ingressClassName
- The Ingress field that says which IngressClass (so which controller) should serve it. Without it, and without a default class, the Ingress is ignored. Lesson 18.19
- internalTrafficPolicy
- Like externalTrafficPolicy, for traffic from inside the cluster: Local sends it only to pods on the caller's own node. Lesson 18.6
- IPAddressPool
- A MetalLB object listing the addresses it may hand out to LoadBalancer Services. Lesson 18.6
- IPAM
- IP address management: the part of a network plugin that hands out free addresses and remembers who has which. Lesson 18.35
- ipBlock
- A NetworkPolicy peer given as a CIDR (with optional except ranges), for addresses outside the cluster. Lesson 18.29
- IPIP (IP-in-IP, tunl0)
- A tunnel that wraps one IP packet inside another (20 extra bytes). Calico uses it between nodes via the tunl0 interface. Lesson 18.35
- iptables (iptables-save)
- The command that reads and writes the kernel's packet rules: which packets to accept, drop, reject or rewrite. kube-proxy's default mode writes its Service rules with it.
iptables -t nat -L CHAIN -nlists one chain;iptables-savedumps every rule as the command that makes it. Lesson 18.3 - iptables chain (chain, KUBE-SERVICES, KUBE-SVC)
- A named, ordered list of packet rules checked top to bottom. kube-proxy creates KUBE-SERVICES (one rule per Service port), KUBE-SVC-... (one per Service) and KUBE-SEP-... (one per endpoint). Lesson 18.3
- iptables table (nat table, filter table)
- A group of packet rules for one purpose: nat rewrites addresses, filter accepts, drops or rejects. Lesson 18.3
- IPVS (IP Virtual Server, ipvs)
- A load balancer built into the Linux kernel: a virtual IP:port with a list of real servers behind it. kube-proxy can use it instead of iptables rules. Lesson 18.3
- ipvsadm
- The command that shows and edits the kernel's IPVS virtual servers.
ipvsadm -Lnlists them with numeric addresses. Lesson 18.3 - isolated pod (isolation, isolated)
- A pod that some NetworkPolicy selects for a direction. From then on only traffic a policy allows passes in that direction; a pod no policy selects allows everything. Lesson 18.29
- Issuer (ClusterIssuer)
- A cert-manager object describing where certificates come from (Let's Encrypt, an internal CA...). ClusterIssuer is the same for the whole cluster. Lesson 18.22
- kube-dns
- The Service in kube-system (ClusterIP 10.96.0.10 here) that every pod uses as its DNS server. The name is historical; CoreDNS pods are behind it. Lesson 18.13
- kube-ipvs0
- A dummy network interface that kube-proxy in IPVS mode puts every ClusterIP on - which is why ClusterIPs answer ping in that mode only. Lesson 18.3
- kube-proxy mode (proxy mode)
- How kube-proxy programs the kernel for Services: iptables (the default), nftables (the newer replacement) or ipvs (on its way out). Set in the kube-proxy ConfigMap, read only at start. Lesson 18.3
- kubectl debug node (node-debugger)
- Starts a pod on a chosen node that shares the node's network and mounts its whole filesystem at /host, so you can inspect the node. The pod is left behind until you delete it. Lesson 18.3
- kubernetes plugin
- The CoreDNS plugin that answers the cluster zone (cluster.local) from the API: Services, EndpointSlices and pods. Lesson 18.13
- kubernetes.io/metadata.name
- A label the API server puts on every namespace automatically, holding its name - the reliable way to select one exact namespace. Lesson 18.29
- L2Advertisement
- A MetalLB object that tells its speakers to answer ARP for a pool's addresses (layer-2 mode). Without one the IP is assigned but unreachable. Lesson 18.6
- lameduck
- A CoreDNS health setting: keep answering for a few seconds after being told to stop, so in-flight lookups finish. Lesson 18.13
- listener (listeners)
- One port and protocol a Gateway accepts traffic on, with optional hostname, TLS settings and allowedRoutes. Lesson 18.26
- LoadBalancer (type LoadBalancer)
- A Service type that asks for a real external load balancer with its own address in front of the node ports. A cloud or MetalLB must provide it; otherwise EXTERNAL-IP stays <pending>. Lesson 18.6
- log plugin
- The CoreDNS plugin that prints one log line per query answered. Useful to investigate, expensive to leave on. Lesson 18.14
- loop plugin
- The CoreDNS plugin that detects queries being forwarded back to CoreDNS itself and stops the server with "Loop ... detected". Lesson 18.13
- masquerade (MASQUERADE, KUBE-MARK-MASQ)
- SNAT to the address of the machine's own outgoing interface. kube-proxy marks some Service traffic for masquerade so replies come back through the same node. Lesson 18.3
- maxPods
- The kubelet setting for the most pods one node may run (110 by default). Lesson 18.35
- MetalLB
- A load-balancer add-on for clusters without a cloud: it gives LoadBalancer Services an IP from a pool and makes the network deliver that IP to a node. Lesson 18.6
- MetalLB speaker (speaker, speakers)
- MetalLB's per-node pod (a DaemonSet) that announces the assigned IPs to the network. Lesson 18.6
- Multi-Attach error (Multi-Attach)
- The event when a pod on one node wants an RWO volume that is still attached to another node; the pod waits in ContainerCreating. Lesson 18.41
- named port (named targetPort)
- A container port with a name (like http). A Service that targets the name reaches each pod on whatever number that pod gave the name. Lesson 18.1
- namespaceSelector
- A NetworkPolicy peer that selects namespaces by label - every pod in them, or only pods matching a podSelector given in the same peer. Lesson 18.29
- netfilter
- The packet-filtering machinery inside the Linux kernel. iptables, nftables and IPVS all program it. Lesson 18.3
- NetworkPolicy (NetworkPolicies, netpol)
- A firewall rule for pods, written as a Kubernetes object: it selects pods by label and lists which traffic may reach them (ingress) and which they may send (egress). Lesson 18.29
- nftables (nft)
- The newer Linux packet-rule system that replaces iptables, using fast lookup tables instead of long rule lists. kube-proxy has an nftables mode. Lesson 18.3
- node network (node CIDR)
- The LAN or cloud subnet the nodes themselves sit in. It must not overlap the pod or service ranges. Lesson 18.35
- node port range
- The ports NodePort Services may use: 30000-32767 by default. The API server refuses others. Lesson 18.6
- NodeLocal DNSCache
- A small caching DNS server on every node (a DaemonSet), so pods ask their own node instead of going over the network to CoreDNS. Lesson 18.14
- NodePort (node port, nodePort)
- A Service type that opens the same port (30000-32767) on every node's IP and forwards it to the Service - like Docker's -p, but on every node. Lesson 18.6
- object storage
- Storing files through an HTTP API (put and get by name) instead of a mounted filesystem. Lesson 18.41
- parentRefs
- The HTTPRoute field naming the Gateway (and optionally listener) the route attaches to. Lesson 18.26
- pathType (Prefix, Exact, ImplementationSpecific)
- How an Ingress compares paths: Exact (the same string only), Prefix (whole path pieces between slashes: /api matches /api/x but not /apis), or ImplementationSpecific (up to the controller). Lesson 18.19
- peer (peers)
- One entry under from or to in a NetworkPolicy rule: the other end of the connection, given as a podSelector, a namespaceSelector, both, or an ipBlock. Lesson 18.29
- PersistentVolume
- A cluster-wide object that represents a real piece of storage (a disk, an NFS export), with size, access modes and reclaim policy. Created by an admin or by a provisioner. Lesson 18.37
- persistentVolumeClaimRetentionPolicy (whenDeleted, whenScaled)
- A StatefulSet setting that decides whether its claims are deleted with the StatefulSet (whenDeleted) or on scale-down (whenScaled). Default: keep them. Lesson 18.44
- pod CIDR (pod network, pod-network-cidr, cluster CIDR)
- The address range all pod IPs come from (10.244.0.0/16 here), chosen when the cluster is built. Lesson 18.35
- pod DNS record (pod A record, pod.cluster.local)
- A name like 10-244-1-16.shop.pod.cluster.local: a pod IP with dashes. With "pods insecure" CoreDNS answers it for any IP without checking. Lesson 18.13
- pod sandbox
- The network namespace a pod's containers share, held open by a tiny pause container that the runtime starts first. Lesson 18.35
- podCIDR (per-node pod CIDR, pod block)
- One node's slice of the pod range (a /24 here), in the Node object's spec.podCIDR; that node's pods get IPs from it. Lesson 18.35
- podSelector
- A label selector for pods. At the top of a NetworkPolicy it picks the pods the policy protects; as a peer it picks pods in the policy's own namespace. Lesson 18.29
- policyTypes
- The NetworkPolicy field listing which directions it isolates: Ingress, Egress, or both. A policy with only Ingress leaves egress wide open. Lesson 18.29
- projected volume (projected)
- A volume that merges several sources (a ServiceAccount token, ConfigMaps, Secrets) into one directory. Lesson 18.37
- provisioner
- The program that creates real storage when a claim needs a volume - usually a CSI driver named in the StorageClass. Lesson 18.39
- proxy ARP
- Answering ARP requests on behalf of another address. Calico uses it so pods send everything to a made-up gateway that the node answers for. Lesson 18.35
- publishNotReadyAddresses
- A Service setting that puts pods in DNS before they are Ready - needed when database members must find each other to become ready at all. Lesson 18.6
- PV node affinity (volume node affinity, volume node affinity conflict)
- The rule on a PV saying which nodes can use it (for a zonal disk: nodes in its zone). "volume node affinity conflict" = the pod's volume cannot be used from that node. Lesson 18.41
- PV status (Available, Released, Pending (PVC))
- A PV is Available (free), Bound (taken), Released (its claim was deleted, data kept) or Failed. A claim is Pending until bound. Lesson 18.39
- pvc-protection (kubernetes.io/pvc-protection, pv-protection)
- The finalizer that keeps a claim from being deleted while a pod still uses it. Lesson 18.44
- RBD (Ceph RBD)
- Ceph's block device: a network disk served by a Ceph cluster. One node mounts it at a time, like a cloud disk. Lesson 18.39
- Ready (READY, not ready)
- A pod condition: its containers are up and pass their readiness check. Only Ready pods receive traffic from a Service. Lesson 18.1
- reclaim policy (reclaimPolicy, persistentVolumeReclaimPolicy, Retain)
- What happens to a PV when its claim is deleted: Delete (the volume and the real storage go) or Retain (kept as Released, data intact). Lesson 18.39
- ReferenceGrant
- A Gateway API object in a namespace that allows routes from another namespace to point at its Services. Without it: RefNotPermitted. Lesson 18.26
- RefNotPermitted
- The route condition reason when it points at a Service in another namespace that has no ReferenceGrant allowing it. Lesson 18.26
- reload plugin
- The CoreDNS plugin that re-reads the Corefile every ~30 s and applies it if it changed. A broken file is rejected and the old config kept. Lesson 18.13
- rewrite-target
- An ingress-nginx annotation that changes the request path before passing it to the backend, e.g. /api/orders becomes /orders. Lesson 18.19
- route conditions (Accepted, ResolvedRefs, NotAllowedByListeners)
- The status entries of a route: Accepted (the Gateway took it) and ResolvedRefs (all its Services were found and allowed), each True/False with a reason. Lesson 18.26
- ROX (ReadOnlyMany)
- ReadOnlyMany: read-only, by many nodes at once. Lesson 18.41
- RWO (ReadWriteOnce)
- ReadWriteOnce: read-write by one NODE at a time (any number of pods on that node). Lesson 18.41
- RWOP (ReadWriteOncePod)
- ReadWriteOncePod: read-write by exactly one pod in the whole cluster. Lesson 18.41
- RWX (ReadWriteMany)
- ReadWriteMany: read-write by many nodes at once. Needs shared file storage such as NFS. Lesson 18.41
- server block
- A section of the Corefile, zone:port { plugins }, that handles the names under one zone. The block with the most specific zone wins. Lesson 18.13
- Service (Services)
- A Kubernetes object that gives a changing group of pods one stable IP and DNS name, and spreads connections over whichever of those pods are Ready right now. Its label selector picks the pods.
kubectl get svclists them;kubectl exposecreates one. Lesson 18.1 - service CIDR (service range, service-cluster-ip-range)
- The address range reserved for Service ClusterIPs, fixed when the cluster is built (10.96.0.0/12 here). It must not overlap the pod or node ranges. Lesson 18.1
- service DNS name (svc.cluster.local)
- The name CoreDNS gives every Service: <service>.<namespace>.svc.<cluster domain>, e.g. web.shop.svc.cluster.local, answering with its ClusterIP. Lesson 18.13
- service environment variables (enableServiceLinks, service links)
- Variables like WEB_SERVICE_HOST that Kubernetes puts into pods for Services that already existed when the pod started. An old convention; use DNS names instead. Lesson 18.1
- service mesh
- An extra layer of proxies next to every pod that handles traffic between services (retries, encryption, traffic splits).
- Service type (spec.type)
- How far a Service reaches: ClusterIP (inside the cluster), NodePort (a port on every node), LoadBalancer (an external load balancer), ExternalName (a DNS alias). Lesson 18.6
- sessionAffinity (session affinity, ClientIP affinity)
- A Service setting (ClientIP) that keeps sending the same client IP to the same pod for a while (3 hours by default). Lesson 18.6
- static provisioning
- An admin creates the PersistentVolume by hand (usually for storage that already exists), and a claim binds to it. Lesson 18.39
- StorageClass (storage class, sc)
- A named kind of storage: which provisioner creates volumes, with which parameters, reclaim policy and binding mode. Lesson 18.39
- storageClassName "" (empty storageClassName)
- An explicit empty class on a claim: "no class, bind to a class-less static PV". Omitting the field instead means "the default class". Lesson 18.39
- stub domain
- One DNS zone that CoreDNS sends to its own chosen server instead of the normal upstream - a second server block with its own forward.
- targetPort (target port)
- The port on the pods that a Service sends traffic to - a number, or the name of a container port. Defaults to the Service port. Lesson 18.1
- three-tier app (three tiers)
- An app split into a frontend, a backend and a database, each only talking to its neighbour. Lesson 18.31
- TLS passthrough (ssl-passthrough, passthrough)
- A proxy mode where the proxy does not decrypt: it routes on the SNI name only and the pod ends TLS itself. Lesson 18.22
- TLS Secret (kubernetes.io/tls, tls Secret, secret tls)
- A Secret of type kubernetes.io/tls holding a certificate (tls.crt, ideally the full chain) and its private key (tls.key), used by an Ingress to serve HTTPS. Lesson 18.22
- topology label (topology.kubernetes.io/zone, topology)
- A node label saying where the node sits, like topology.kubernetes.io/zone=lab-b. Volumes and the scheduler use it. Lesson 18.41
- volume (Kubernetes) (volumeMounts)
- Storage attached to a pod: declared under the pod's volumes, and mounted into containers with volumeMounts. Its type decides how long the data lives. Lesson 18.37
- volume expansion (allowVolumeExpansion, resize)
- Growing a claim by raising its requested size. Only if its class has allowVolumeExpansion: true; volumes never shrink. Lesson 18.44
- VolumeAttachment
- The object recording that a block volume is attached to a node (ATTACHER, PV, NODE, ATTACHED). Lesson 18.41
- volumeBindingMode (Immediate, WaitForFirstConsumer, WFFC)
- When a class creates the volume: Immediate (as soon as the claim exists) or WaitForFirstConsumer (after a pod using it is scheduled, in that node's zone). Lesson 18.41
- volumeName
- The field on a claim naming its PV; set it yourself to bind a claim to one exact volume. Lesson 18.39
- VolumeSnapshot (snapshot, snapshots)
- A point-in-time copy of a volume, requested as a Kubernetes object and made by the CSI driver. Part of a backup, not a backup on its own. Lesson 18.44
- VXLAN
- A tunnel format that wraps network frames inside UDP packets (port 4789); used by Flannel and Calico's VXLAN mode. Lesson 18.35