content large_stringlengths 3 20.5k | url large_stringlengths 54 193 | branch large_stringclasses 4
values | source large_stringclasses 42
values | embeddings listlengths 384 384 | score float64 -0.21 0.65 |
|---|---|---|---|---|---|
Nodes have local ephemeral storage, backed by locally-attached writeable devices or, sometimes, by RAM. "Ephemeral" means that there is no long-term guarantee about durability. Pods use ephemeral local storage for scratch space, caching, and for logs. The kubelet can provide scratch space to Pods using local ephemeral ... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/storage/ephemeral-storage.md | main | kubernetes | [
0.01369106862694025,
0.03762815520167351,
0.05522778630256653,
0.028032928705215454,
0.012470952235162258,
-0.04762090742588043,
-0.018102530390024185,
0.029156213626265526,
0.09794659912586212,
0.04269580915570259,
-0.008187946863472462,
-0.05077235400676727,
0.009183380752801895,
-0.0227... | 0.190095 |
local ephemeral storage. {{< /note >}} {{< note >}} The kubelet will only track the root filesystem for ephemeral storage. OS layouts that mount a separate disk to `/var/lib/kubelet` or `/var/lib/containers` will not report ephemeral storage correctly. {{< /note >}} ## Setting requests and limits for local ephemeral st... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/storage/ephemeral-storage.md | main | kubernetes | [
0.02976011112332344,
0.0832730233669281,
0.005571207497268915,
-0.0019709020853042603,
-0.03028862550854683,
-0.040906306356191635,
-0.0020331479609012604,
0.059312645345926285,
0.0882437452673912,
0.002974895993247628,
0.006662522442638874,
-0.0767301395535469,
-0.01293016504496336,
-0.02... | 0.142883 |
`emptyDir` volumes falls low, the node {{< glossary\_tooltip text="taints" term\_id="taint" >}} itself as short on local storage and this taint triggers eviction for any Pods that don't specifically tolerate the taint. See the supported [configurations](#configurations) for ephemeral local storage. {{< /caution >}} The... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/storage/ephemeral-storage.md | main | kubernetes | [
0.01246321015059948,
0.04231605678796768,
0.06096859648823738,
0.03356693312525749,
0.016301319003105164,
-0.05991533398628235,
0.02367573231458664,
-0.0024822622071951628,
0.16193042695522308,
0.017595335841178894,
0.01426009926944971,
-0.05492798984050751,
-0.01616084761917591,
-0.029214... | 0.170057 |
the [kubelet configuration](/docs/reference/config-api/kubelet-config.v1beta1/). {{% /tab %}} {{< /tabs >}} ## {{% heading "whatsnext" %}} \* Read about [project quotas](https://www.linux.org/docs/man8/xfs\_quota.html) in XFS | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/storage/ephemeral-storage.md | main | kubernetes | [
0.07742432504892349,
0.0033816585782915354,
-0.03238198906183243,
-0.06437946110963821,
0.003616525325924158,
-0.00988161563873291,
0.03662776201963425,
0.05173501372337341,
0.07161278277635574,
0.0106672877445817,
0.02024233713746071,
-0.08847571164369583,
0.034200962632894516,
0.02507068... | 0.089498 |
This page describes the maximum number of volumes that can be attached to a Node for various cloud providers. Cloud providers like Google, Amazon, and Microsoft typically have a limit on how many volumes can be attached to a Node. It is important for Kubernetes to respect those limits. Otherwise, Pods scheduled on a No... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/storage/storage-limits.md | main | kubernetes | [
0.01650424487888813,
-0.028903089463710785,
0.048529598861932755,
0.009387269616127014,
-0.025177543982863426,
0.01048780046403408,
-0.09080570191144943,
-0.006535973399877548,
0.07361065596342087,
0.05717209354043007,
-0.06507131457328796,
0.037200525403022766,
0.06331241875886917,
-0.001... | 0.041396 |
nodes that do not yet have CSI driver installed. This limitation only applies to pods that require corresponding CSI volume. | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/storage/storage-limits.md | main | kubernetes | [
0.0759049504995346,
-0.044830322265625,
0.004275618586689234,
-0.01152909267693758,
0.01657550409436226,
-0.05853020399808884,
-0.07911494374275208,
-0.03095390275120735,
-0.0384722463786602,
0.05379097908735275,
0.030761612579226494,
-0.027554785832762718,
0.0332680344581604,
0.0270669460... | 0.145495 |
Kubernetes \_volumes\_ provide a way for containers in a {{< glossary\_tooltip text="Pod" term\_id="pod" >}} to access and share data via the filesystem. There are different kinds of volume that you can use for different purposes, such as: - populating a configuration file based on a {{< glossary\_tooltip text="ConfigM... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/storage/volumes.md | main | kubernetes | [
-0.06934083253145218,
0.0026714331470429897,
0.05597236379981041,
0.0068943677470088005,
-0.007250917609781027,
-0.034288059920072556,
0.06986643373966217,
-0.0029261528979986906,
0.0527954176068306,
0.01698337309062481,
0.009296850301325321,
-0.05079301446676254,
0.023955946788191795,
-0.... | 0.088476 |
a subsequent filesystem access. Volumes are mounted at [specified paths](#using-subpath) within the container filesystem. For each container defined within a Pod, you must independently specify where to mount each volume that the container uses. Volumes cannot mount within other volumes (but see [Using subPath](#using-... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/storage/volumes.md | main | kubernetes | [
0.05892137065529823,
-0.0438353456556797,
0.05365642532706261,
0.006807579193264246,
0.030595354735851288,
-0.04159582406282425,
0.0026570484042167664,
0.03356258198618889,
0.05330267176032066,
0.01588740199804306,
-0.01438396517187357,
-0.030582193285226822,
0.03759133815765381,
0.0049968... | 0.126748 |
network storage, depending on your environment. If you set the `emptyDir.medium` field to `"Memory"`, Kubernetes mounts a tmpfs (RAM-backed filesystem) for you instead. While tmpfs is very fast, be aware that, unlike disks, files you write count against the memory limit of the container that wrote them. A size limit ca... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/storage/volumes.md | main | kubernetes | [
0.08908697217702866,
0.02538680098950863,
0.004336112178862095,
0.030932627618312836,
0.07306604832410812,
-0.014054360799491405,
-0.048466756939888,
0.042635951191186905,
0.15464146435260773,
0.0899784043431282,
0.024567898362874985,
0.02197018265724182,
-0.019133729860186577,
-0.01208646... | 0.106633 |
or directory from the host node's filesystem into your Pod. This is not something that most Pods will need, but it offers a powerful escape hatch for some applications. {{< warning >}} Using the `hostPath` volume type presents many security risks. If you can avoid using a `hostPath` volume, you should. For example, def... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/storage/volumes.md | main | kubernetes | [
0.05727105960249901,
0.05277453735470772,
0.029667958617210388,
0.038471516221761703,
0.02516085095703602,
-0.04584626480937004,
-0.010074762627482414,
0.027276895940303802,
0.08039817959070206,
0.058501508086919785,
-0.008124161511659622,
0.005110559519380331,
0.01806926727294922,
-0.0132... | 0.155192 |
`hostPath`. {{< /caution >}} Some files or directories created on the underlying hosts might only be accessible by root. You then either need to run your process as root in a [privileged container](/docs/tasks/configure-pod-container/security-context/) or modify the file permissions on the host to read from or write to... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/storage/volumes.md | main | kubernetes | [
0.08631777763366699,
0.002033836208283901,
-0.021534768864512444,
-0.019391726702451706,
0.035095904022455215,
-0.06923819333314896,
-0.021288374438881874,
0.049458395689725876,
-0.0033710459247231483,
0.05376393720507622,
-0.028244607150554657,
-0.04270600154995918,
-0.02493852563202381,
... | 0.145553 |
reference isn't present and the pull fails. The volume gets re-resolved if the Pod gets deleted and recreated, which means that new remote content will become available on Pod recreation. A failure to resolve or pull the image during Pod startup will block containers from starting and may add significant latency. Failu... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/storage/volumes.md | main | kubernetes | [
0.024048548191785812,
-0.005108408629894257,
0.07961113750934601,
0.03260941803455353,
0.06310706585645676,
-0.04146734997630119,
-0.026199553161859512,
0.07747358828783035,
0.061849068850278854,
-0.003976914100348949,
-0.004077961668372154,
0.0009093529661186039,
-0.028126366436481476,
0.... | 0.099698 |
then the `local` volume becomes inaccessible to the Pod. The Pod using this volume is unable to run. Applications using `local` volumes must be able to tolerate this reduced availability, as well as potential data loss, depending on the durability characteristics of the underlying disk. The following example shows a Pe... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/storage/volumes.md | main | kubernetes | [
0.037949156016111374,
0.0012690841685980558,
0.041451796889305115,
0.032174453139305115,
0.01603860966861248,
-0.012730901129543781,
-0.09029347449541092,
-0.012616800144314766,
0.09083463251590729,
0.02276875078678131,
-0.018116958439350128,
0.015596868470311165,
0.016438620164990425,
0.0... | 0.091453 |
pre-provisioned and referenced inside a Pod. Here is an example Pod referencing a pre-provisioned Portworx volume: ```yaml apiVersion: v1 kind: Pod metadata: name: test-portworx-volume-pod spec: containers: - image: registry.k8s.io/test-webserver name: test-container volumeMounts: - mountPath: /mnt name: pxvol volumes:... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/storage/volumes.md | main | kubernetes | [
0.0490918904542923,
-0.032118674367666245,
0.05291769653558731,
-0.01484515331685543,
-0.0059941732324659824,
-0.021315915510058403,
-0.049381107091903687,
-0.00520411878824234,
0.036363791674375534,
0.03463323041796684,
0.03228573873639107,
-0.05450145900249481,
-0.004093139432370663,
0.0... | 0.024547 |
the filesystem holding the kubelet root dir (typically `/var/lib/kubelet`). There is no limit on how much space an `emptyDir` or `hostPath` volume can consume, and no isolation between containers or Pods. To learn about requesting space using a resource specification, see [how to manage resources](/docs/concepts/config... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/storage/volumes.md | main | kubernetes | [
0.002259644214063883,
-0.03523226082324982,
0.003382336348295212,
0.0008863454568199813,
-0.011260578408837318,
-0.04924548789858818,
-0.05560080707073212,
0.0684836357831955,
0.12176593393087387,
0.035740628838539124,
0.00876853708177805,
-0.04283131659030914,
0.0005246542277745903,
-0.04... | 0.147755 |
to the CSI driver via the `VolumeCapability` field of `ControllerPublishVolumeRequest`, `NodeStageVolumeRequest`, and `NodePublishVolumeRequest`. \* `volumeAttributes`: A map of string to string that specifies static properties of a volume. This map must correspond to the map returned in the `volume.attributes` field o... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/storage/volumes.md | main | kubernetes | [
0.048248156905174255,
0.0025499809999018908,
-0.061888862401247025,
0.014077159576117992,
-0.026066185906529427,
-0.03915264829993248,
0.044719796627759933,
0.029879778623580933,
0.01694997027516365,
0.02394590713083744,
0.03812342882156372,
-0.06315804272890091,
0.07714635878801346,
0.013... | 0.124855 |
deployment guide of the CSI plugin you wish to deploy. #### Migrating to CSI drivers from in-tree plugins {{< feature-state for\_k8s\_version="v1.25" state="stable" >}} The `CSIMigration` feature directs operations against existing in-tree plugins to corresponding CSI plugins (which are expected to be installed and con... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/storage/volumes.md | main | kubernetes | [
-0.0029273885302245617,
-0.0036748447455465794,
0.02562546171247959,
-0.030180586501955986,
0.008139261975884438,
-0.04843052476644516,
-0.00248141516931355,
-0.027295177802443504,
-0.011081726290285587,
0.06939712166786194,
0.033511966466903687,
-0.04953993484377861,
0.03289065882563591,
... | 0.119319 |
not applicable. cri-dockerd (Docker) is known to choose `rslave` mount propagation when the mount source contains the Docker daemon's root directory (`/var/lib/docker`). \* `HostToContainer` - This volume mount will receive all subsequent mounts that are mounted to this volume or any of its subdirectories. In other wor... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/storage/volumes.md | main | kubernetes | [
-0.005722847301512957,
0.02038971707224846,
0.02484796941280365,
-0.013642418198287487,
0.03862664848566055,
-0.0534675195813179,
-0.03873847424983978,
0.005609272979199886,
0.007810758426785469,
-0.045101359486579895,
-0.015415028668940067,
-0.038973141461610794,
0.04900014027953148,
0.02... | 0.001658 |
[deploying WordPress and MySQL with Persistent Volumes](/docs/tutorials/stateful-application/mysql-wordpress-persistent-volume/). | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/storage/volumes.md | main | kubernetes | [
0.014600363560020924,
-0.07253104448318481,
-0.07426697015762329,
-0.02853982523083687,
-0.04239515960216522,
-0.06515571475028992,
-0.025288769975304604,
0.026971139013767242,
-0.024564629420638084,
0.03688750043511391,
0.011142072267830372,
0.07533199340105057,
0.13185593485832214,
0.045... | 0.068942 |
Dynamic volume provisioning allows storage volumes to be created on-demand. Without dynamic provisioning, cluster administrators have to manually make calls to their cloud or storage provider to create new storage volumes, and then create [`PersistentVolume` objects](/docs/concepts/storage/persistent-volumes/) to repre... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/storage/dynamic-provisioning.md | main | kubernetes | [
-0.011999002657830715,
0.004485737532377243,
0.017000872641801834,
0.07468497008085251,
-0.07576479762792587,
-0.0011611009249463677,
-0.01640816405415535,
0.011259774677455425,
0.09346860647201538,
0.024566123262047768,
-0.04060031846165657,
-0.021836737170815468,
0.0652887299656868,
0.02... | 0.09846 |
the most recently created default StorageClass. ## Topology Awareness In [Multi-Zone](/docs/setup/best-practices/multiple-zones/) clusters, Pods can be spread across Zones in a Region. Single-Zone storage backends should be provisioned in the Zones where Pods are scheduled. This can be accomplished by setting the [Volu... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/storage/dynamic-provisioning.md | main | kubernetes | [
0.08350265026092529,
-0.07330183684825897,
-0.04080262780189514,
0.025361238047480583,
-0.02018948644399643,
-0.012251784093677998,
-0.10314327478408813,
0.03286922350525856,
-0.015623015351593494,
0.04588726535439491,
-0.013698983937501907,
0.0169083159416914,
-0.011440964415669441,
-0.00... | 0.121394 |
{{< feature-state feature\_gate\_name="VolumeAttributesClass" >}} This page assumes that you are familiar with [StorageClasses](/docs/concepts/storage/storage-classes/), [volumes](/docs/concepts/storage/volumes/) and [PersistentVolumes](/docs/concepts/storage/persistent-volumes/) in Kubernetes. A VolumeAttributesClass ... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/storage/volume-attributes-classes.md | main | kubernetes | [
-0.051943160593509674,
0.014168213121592999,
0.039000265300273895,
0.011719712056219578,
-0.05009860917925835,
-0.010575768537819386,
0.03376656398177147,
-0.06631153076887131,
0.06868965178728104,
0.012838912196457386,
-0.057218942791223526,
0.010957563295960426,
0.041465308517217636,
-0.... | 0.058793 |
{{< feature-state for\_k8s\_version="v1.21" state="alpha" >}} {{< glossary\_tooltip text="CSI" term\_id="csi" >}} volume health monitoring allows CSI Drivers to detect abnormal volume conditions from the underlying storage systems and report them as events on {{< glossary\_tooltip text="PVCs" term\_id="persistent-volum... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/storage/volume-health-monitoring.md | main | kubernetes | [
-0.07931561022996902,
0.05620803311467171,
0.06579077243804932,
0.012395517900586128,
0.00035596100497059524,
-0.028666406869888306,
0.1044178158044815,
-0.021331045776605606,
0.08047115057706833,
0.009692047722637653,
0.02930580824613571,
-0.06410321593284607,
0.01615528017282486,
0.01741... | 0.161483 |
If you want to control traffic flow at the IP address or port level for TCP, UDP, and SCTP protocols, then you might consider using Kubernetes NetworkPolicies for particular applications in your cluster. NetworkPolicies are an application-centric construct which allow you to specify how a {{< glossary\_tooltip text="po... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/network-policies.md | main | kubernetes | [
0.0010393868433311582,
-0.047689199447631836,
0.002772331004962325,
-0.007307649124413729,
-0.04775223135948181,
0.0724111795425415,
0.04240997135639191,
-0.006158354226499796,
0.03924407437443733,
0.056225985288619995,
-0.05986827239394188,
-0.039314430207014084,
0.0030581080354750156,
-0... | 0.180218 |
the connections allowed in that direction from that pod is the union of what the applicable policies allow. Thus, order of evaluation does not affect the policy result. For a connection from a source pod to a destination pod to be allowed, both the egress policy on the source pod and the ingress policy on the destinati... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/network-policies.md | main | kubernetes | [
-0.014719601720571518,
0.05959124118089676,
0.0339830256998539,
0.009584128856658936,
-0.01479928195476532,
0.017325080931186676,
0.024562714621424675,
-0.033262237906455994,
0.01099588256329298,
0.08669853210449219,
-0.037561677396297455,
0.04967385157942772,
0.01583443209528923,
-0.02819... | 0.123141 |
selects particular namespaces for which all Pods should be allowed as ingress sources or egress destinations. \*\*namespaceSelector\*\* \*and\* \*\*podSelector\*\*: A single `to`/`from` entry that specifies both `namespaceSelector` and `podSelector` selects particular Pods within particular namespaces. Be careful to us... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/network-policies.md | main | kubernetes | [
-0.009545957669615746,
-0.012546523474156857,
0.015078946016728878,
0.014350240118801594,
0.010661465115845203,
-0.0034608403220772743,
0.1378049999475479,
-0.09067415446043015,
0.07467613369226456,
0.0229016225785017,
0.02209281735122204,
-0.0884178876876831,
0.004956847056746483,
-0.0423... | 0.158183 |
you want to allow all connections from all pods in a namespace, you can create a policy that explicitly allows all outgoing connections from pods in that namespace. {{% code\_sample file="service/networking/network-policy-allow-all-egress.yaml" %}} With this policy in place, no additional policy or policies can cause a... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/network-policies.md | main | kubernetes | [
0.005731950048357248,
0.03427585959434509,
0.030840273946523666,
-0.0044077313505113125,
-0.011837907135486603,
-0.023107925429940224,
0.0915643721818924,
-0.04498683288693428,
-0.015659643337130547,
0.0770149827003479,
-0.001491713454015553,
-0.04079795256257057,
0.018389776349067688,
-0.... | 0.161499 |
by its name The Kubernetes control plane sets an immutable label `kubernetes.io/metadata.name` on all namespaces, the value of the label is the namespace name. While NetworkPolicy cannot target a namespace by its name with some object field, you can use the standardized label to target a specific namespace. ## Pod life... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/network-policies.md | main | kubernetes | [
-0.04350575804710388,
-0.042286522686481476,
0.001231132890097797,
0.028670279309153557,
0.022915497422218323,
-0.002323444467037916,
0.030777286738157272,
-0.0493059940636158,
0.08957687020301819,
0.023797575384378433,
0.012726258486509323,
-0.03278793767094612,
0.013312187045812607,
-0.0... | 0.169137 |
selected by a `podSelector` or `namespaceSelector` in an `ingress` or `egress` rule. ```yaml ... ingress: - from: - podSelector: matchLabels: role: client ... ``` At the same time, since `hostNetwork` pods have the same IP addresses as the nodes they reside on, their connections will be treated as node connections. For... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/network-policies.md | main | kubernetes | [
-0.02151154726743698,
0.03563186898827553,
0.02779628336429596,
-0.023599840700626373,
-0.016257597133517265,
0.02527192234992981,
0.07521989941596985,
-0.028390873223543167,
0.046995729207992554,
0.09442614018917084,
-0.056951235979795456,
-0.013771764934062958,
0.031090879812836647,
-0.0... | 0.136037 |
{{< feature-state for\_k8s\_version="v1.21" state="stable" >}} {{< glossary\_definition term\_id="endpoint-slice" length="short" >}} ## EndpointSlice API {#endpointslice-resource} In Kubernetes, an EndpointSlice contains references to a set of network endpoints. The control plane automatically creates EndpointSlices fo... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/endpoint-slices.md | main | kubernetes | [
-0.050849564373493195,
-0.021442880854010582,
0.06040291488170624,
-0.0369793102145195,
-0.08037085086107254,
0.0002663839841261506,
0.056271154433488846,
-0.056866880506277084,
0.06469857692718506,
0.02612043172121048,
-0.02076837420463562,
-0.07928316295146942,
-0.03603855147957802,
0.01... | 0.115544 |
can manage EndpointSlices without interfering with each other, Kubernetes defines the {{< glossary\_tooltip term\_id="label" text="label" >}} `endpointslice.kubernetes.io/managed-by`, which indicates the entity managing an EndpointSlice. The endpoint slice controller sets `endpointslice-controller.k8s.io` as the value ... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/endpoint-slices.md | main | kubernetes | [
-0.032541047781705856,
-0.04364633560180664,
0.013463491573929787,
-0.03986993804574013,
-0.04328569397330284,
-0.00895567424595356,
0.060752157121896744,
-0.03376049920916557,
0.12518519163131714,
0.029755912721157074,
0.039561089128255844,
-0.002670726040378213,
-0.026022030040621758,
0.... | 0.162981 |
user workloads that expect {{}} to route traffic based on Endpoints resources, the cluster's control plane mirrors most user-created Endpoints resources to corresponding EndpointSlices. (However, this feature, like the rest of the Endpoints API, is deprecated. Users who manually specify endpoints for selectorless Servi... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/endpoint-slices.md | main | kubernetes | [
0.03339028358459473,
-0.01757519692182541,
0.015050917863845825,
0.011503838934004307,
-0.033326826989650726,
0.005199800245463848,
0.04267757385969162,
-0.07724831998348236,
0.07582063227891922,
0.05524648353457451,
-0.05585288628935814,
-0.026862477883696556,
-0.04851092770695686,
-0.002... | 0.165627 |
{{< feature-state for\_k8s\_version="v1.26" state="stable" >}} \_Service Internal Traffic Policy\_ enables internal traffic restrictions to only route internal traffic to endpoints within the node the traffic originated from. The "internal" traffic here refers to traffic originated from Pods in the current cluster. Thi... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/service-traffic-policy.md | main | kubernetes | [
-0.013033296912908554,
-0.003476128913462162,
0.06445696204900742,
-0.040334198623895645,
-0.06132460758090019,
-0.030105018988251686,
0.036419231444597244,
-0.037559133023023605,
0.005835453048348427,
0.05934176221489906,
-0.0525454506278038,
-0.06109858304262161,
-0.022861793637275696,
-... | 0.150157 |
{{< note >}} The Kubernetes project recommends using [Gateway](https://gateway-api.sigs.k8s.io/) instead of [Ingress](/docs/concepts/services-networking/ingress/). The Ingress API has been frozen. This means that: \* The Ingress API is generally available, and is subject to the [stability guarantees](/docs/reference/us... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/ingress-controllers.md | main | kubernetes | [
-0.07046374678611755,
0.023758385330438614,
0.06350216269493103,
0.007281945087015629,
0.018847672268748283,
0.011248968541622162,
-0.023539235815405846,
-0.025379322469234467,
0.07405360043048859,
0.09093044698238373,
-0.009317146614193916,
0.012628012336790562,
-0.020568421110510826,
-0.... | 0.193641 |
deploy any number of ingress controllers using [ingress class](/docs/concepts/services-networking/ingress/#ingress-class) within a cluster. Note the `.metadata.name` of your ingress class resource. When you create an ingress you would need that name to specify the `ingressClassName` field on your Ingress object (refer ... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/ingress-controllers.md | main | kubernetes | [
-0.011273828335106373,
-0.018194623291492462,
0.02803337574005127,
-0.003807715605944395,
0.01853516697883606,
0.035625990480184555,
0.0685010775923729,
-0.0035199997946619987,
0.023348860442638397,
0.07570566982030869,
0.02422310784459114,
-0.050342097878456116,
0.017313476651906967,
-0.0... | 0.192402 |
{{< feature-state for\_k8s\_version="v1.23" state="stable" >}} IPv4/IPv6 dual-stack networking enables the allocation of both IPv4 and IPv6 addresses to {{< glossary\_tooltip text="Pods" term\_id="pod" >}} and {{< glossary\_tooltip text="Services" term\_id="service" >}}. IPv4/IPv6 dual-stack networking is enabled by de... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/dual-stack.md | main | kubernetes | [
0.03058953769505024,
-0.03081228770315647,
0.07637683302164078,
-0.008849849924445152,
-0.060986146330833435,
0.08496566116809845,
-0.05528591200709343,
-0.06789015978574753,
0.017216084524989128,
0.025845758616924286,
-0.011809994466602802,
-0.04524512216448784,
-0.06752965599298477,
-0.0... | 0.11821 |
an existing Service. {{< /note >}} You can set `.spec.ipFamilies` to any of the following array values: - `["IPv4"]` - `["IPv6"]` - `["IPv4","IPv6"]` (dual stack) - `["IPv6","IPv4"]` (dual stack) The first family you list is used for the legacy `.spec.clusterIP` field. ### Dual-stack Service configuration scenarios The... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/dual-stack.md | main | kubernetes | [
-0.014735838398337364,
-0.02469630539417267,
0.0035155033692717552,
-0.01635027304291725,
-0.036899954080581665,
0.030467621982097626,
-0.018897581845521927,
-0.04083726555109024,
0.03934205323457718,
0.02243996411561966,
-0.004999035038053989,
-0.038997549563646317,
-0.04722537100315094,
... | 0.132311 |
selector: app.kubernetes.io/name: MyApp ``` #### Switching Services between single-stack and dual-stack Services can be changed from single-stack to dual-stack and from dual-stack to single-stack. 1. To change a Service from single-stack to dual-stack, change `.spec.ipFamilyPolicy` from `SingleStack` to `PreferDualStac... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/dual-stack.md | main | kubernetes | [
0.0011108232429251075,
-0.06242837756872177,
0.06051556393504143,
-0.04504521191120148,
-0.08280476927757263,
0.019668390974402428,
-0.03465991094708443,
-0.04821963235735893,
0.0699719488620758,
0.034589797258377075,
-0.006474699825048447,
-0.08085132390260696,
-0.05985286086797714,
-0.02... | 0.010426 |
Make network services available by using an extensible, role-oriented, protocol-aware configuration mechanism. [Gateway API](https://gateway-api.sigs.k8s.io/) is an {{}} containing API [kinds](https://gateway-api.sigs.k8s.io/references/spec/) that provide dynamic infrastructure provisioning and advanced traffic routing... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/gateway.md | main | kubernetes | [
-0.000576856080442667,
0.0009230999858118594,
0.02721594274044037,
-0.02612561732530594,
-0.09122608602046967,
0.023153426125645638,
0.013039088808000088,
0.030469980090856552,
0.038384515792131424,
0.01994279958307743,
-0.10429506003856659,
-0.03030567616224289,
0.004698611795902252,
-0.0... | 0.229141 |
name: example-gateway namespace: example-namespace spec: gatewayClassName: example-class listeners: - name: http protocol: HTTP port: 80 hostname: "www.example.com" allowedRoutes: namespaces: from: Same ``` In this example, an instance of traffic handling infrastructure is programmed to listen for HTTP traffic on port ... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/gateway.md | main | kubernetes | [
-0.06392834335565567,
-0.013829914852976799,
-0.006956859026104212,
-0.010615277104079723,
-0.05848880112171173,
-0.04549885168671608,
0.01857895590364933,
-0.04272450879216194,
0.049605805426836014,
-0.0007097342167980969,
-0.05534573271870613,
-0.01606461964547634,
-0.011935302056372166,
... | 0.122221 |
a Gateway and an HTTPRoute: {{< figure src="/docs/images/gateway-request-flow.svg" alt="A diagram that provides an example of HTTP traffic being routed to a Service by using a Gateway and an HTTPRoute" class="diagram-medium" >}} In this example, the request flow for a Gateway implemented as a reverse proxy is: 1. The c... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/gateway.md | main | kubernetes | [
-0.06427282840013504,
-0.011939785443246365,
0.05235781520605087,
-0.03564449027180672,
-0.09125757217407227,
-0.0950801819562912,
0.004654413089156151,
-0.008611706085503101,
0.0691324770450592,
0.0012159564066678286,
-0.08521981537342072,
0.06273402273654938,
-0.01624746434390545,
-0.060... | 0.099719 |
In Kubernetes, [Services](/docs/concepts/services-networking/service/) are an abstract way to expose an application running on a set of Pods. Services can have a cluster-scoped virtual IP address (using a Service of `type: ClusterIP`). Clients can connect using that virtual IP address, and Kubernetes then load-balances... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/cluster-ip-allocation.md | main | kubernetes | [
-0.02728724293410778,
-0.022128542885184288,
0.029045002534985542,
-0.022791579365730286,
-0.038917433470487595,
0.04958697035908699,
0.056921180337667465,
-0.04561040922999382,
0.14854052662849426,
0.04733125492930412,
-0.04151209816336632,
0.004225835204124451,
0.005119341891258955,
-0.0... | 0.186381 |
10.96.0.0/20 "Static" : 256 "Dynamic" : 3838 {{< /mermaid >}} ### Example 3 {#allocation-example-3} This example uses the IP address range: 10.96.0.0/16 (CIDR notation) for the IP addresses of Services. Range Size: 216 - 2 = 65534 Band Offset: `min(max(16, 65536/16), 256)` = `min(4096, 256)` = 256 Static band start: 10... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/cluster-ip-allocation.md | main | kubernetes | [
0.03348657861351967,
0.05907999351620674,
-0.023106319829821587,
-0.045782413333654404,
-0.05230946093797684,
-0.02119813673198223,
0.0419851578772068,
-0.0093269357457757,
-0.0478663295507431,
-0.07889444380998611,
0.007829779759049416,
-0.06788165867328644,
0.01305982656776905,
-0.009773... | 0.09356 |
{{< glossary\_definition term\_id="service" length="short" prepend="In Kubernetes, a Service is" >}} A key aim of Services in Kubernetes is that you don't need to modify your existing application to use an unfamiliar service discovery mechanism. You can run code in Pods, whether this is a code designed for a cloud-nati... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/service.md | main | kubernetes | [
-0.03861651569604874,
-0.009227069094777107,
0.0892239511013031,
-0.01902945339679718,
-0.04158494248986244,
-0.024530842900276184,
0.07997801899909973,
-0.04341964051127434,
0.07005385309457779,
0.039513226598501205,
0.0031212051399052143,
-0.03511407971382141,
0.024311991408467293,
-0.04... | 0.115485 |
>}} for matching EndpointSlices. Kubernetes updates the EndpointSlices for a Service whenever the set of Pods in a Service changes. For non-native applications, Kubernetes offers ways to place a network port or load balancer in between your application and the backend Pods. Either way, your workload can use these [serv... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/service.md | main | kubernetes | [
-0.04236474260687828,
-0.029813634231686592,
0.006027990486472845,
-0.044716741889715195,
-0.06309807300567627,
-0.044258952140808105,
0.056906506419181824,
-0.010601509362459183,
0.09138733893632889,
0.012540234252810478,
-0.0417063906788826,
-0.035015977919101715,
-0.01272389106452465,
-... | 0.214775 |
can abstract other kinds of backends, including ones that run outside the cluster. For example: \* You want to have an external database cluster in production, but in your test environment you use your own databases. \* You want to point your Service to a Service in a different {{< glossary\_tooltip term\_id="namespace... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/service.md | main | kubernetes | [
-0.020778343081474304,
-0.055898990482091904,
0.012492031790316105,
-0.012399525381624699,
-0.04231471195816994,
-0.033524807542562485,
0.03684353828430176,
-0.05169042944908142,
0.05645740404725075,
0.015378684736788273,
-0.01198311522603035,
-0.08102033287286758,
0.019386913627386093,
-0... | 0.168486 |
used as a proxy to endpoints the caller may not be authorized to access. {{< /note >}} An `ExternalName` Service is a special case of Service that does not have selectors and uses DNS names instead. For more information, see the [ExternalName](#externalname) section. ### EndpointSlices {{< feature-state for\_k8s\_versi... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/service.md | main | kubernetes | [
-0.029574962332844734,
-0.03456798940896988,
0.0688752606511116,
-0.02945796586573124,
-0.05797014385461807,
-0.004554991144686937,
0.038213569670915604,
-0.025538545101881027,
0.10752540081739426,
0.030270876362919807,
-0.040214698761701584,
-0.015920568257570267,
-0.005269702523946762,
0... | 0.165323 |
example: ```yaml apiVersion: v1 kind: Service metadata: name: my-service spec: selector: app.kubernetes.io/name: MyApp ports: - name: http protocol: TCP port: 80 targetPort: 9376 - name: https protocol: TCP port: 443 targetPort: 9377 ``` {{< note >}} As with Kubernetes {{< glossary\_tooltip term\_id="name" text="names"... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/service.md | main | kubernetes | [
-0.02508830465376377,
-0.00565542234107852,
0.0406123548746109,
-0.08624358475208282,
-0.06971254199743271,
-0.019129101186990738,
0.032846659421920776,
-0.05503145232796669,
0.0780886635184288,
0.02442931942641735,
0.0016482112696394324,
-0.0775180384516716,
-0.008524280041456223,
0.03429... | 0.104833 |
trying to use the same IP address. ### `type: NodePort` {#type-nodeport} If you set the `type` field to `NodePort`, the Kubernetes control plane allocates a port from a range specified by `--service-node-port-range` flag (default: 30000-32767). Each node proxies that port (the same port number on every Node) into your ... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/service.md | main | kubernetes | [
0.001699679996818304,
-0.023108268156647682,
0.010547744110226631,
-0.021402306854724884,
-0.05850519984960556,
0.03848026692867279,
0.018416503444314003,
-0.030985727906227112,
0.03289271518588066,
0.08401644229888916,
-0.10346058756113052,
-0.00397509103640914,
-0.007448518183082342,
-0.... | 0.106294 |
the port, you can set the `--nodeport-addresses` flag for kube-proxy or the equivalent `nodePortAddresses` field of the [kube-proxy configuration file](/docs/reference/config-api/kube-proxy-config.v1alpha1/) to particular IP block(s). This flag takes a comma-delimited list of IP blocks (e.g. `10.0.0.0/8`, `192.0.2.0/25... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/service.md | main | kubernetes | [
0.014290781691670418,
0.01245839148759842,
0.02999022603034973,
-0.05707179382443428,
-0.06570079922676086,
0.041968751698732376,
-0.011341096833348274,
-0.0292056817561388,
-0.017388727515935898,
0.02064395323395729,
-0.07988732308149338,
-0.0025221998803317547,
0.0025178203359246254,
-0.... | 0.02997 |
extensively used within the context of supporting the `externalTrafficPolicy` field for Services. #### Load balancers with mixed protocol types {{< feature-state feature\_gate\_name="MixedProtocolLBService" >}} By default, for LoadBalancer type of Services, when there is more than one port defined, all ports must have ... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/service.md | main | kubernetes | [
-0.07652967423200607,
-0.024563077837228775,
0.009429258294403553,
-0.05658930912613869,
-0.02222553640604019,
-0.0024040155112743378,
-0.030140433460474014,
-0.007132827769964933,
0.09522034227848053,
-0.005651005543768406,
-0.045449528843164444,
-0.018852345645427704,
0.008174723945558071,... | 0.171608 |
from Services inside the same (virtual) network address block. In a split-horizon DNS environment you would need two Services to be able to route both external and internal traffic to your endpoints. To set an internal load balancer, add one of the following annotations to your Service depending on the cloud service pr... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/service.md | main | kubernetes | [
-0.019175877794623375,
-0.04242492839694023,
0.012465942651033401,
-0.06885448098182678,
-0.07223451137542725,
-0.04489763081073761,
0.028879065066576004,
-0.01796337030827999,
0.0860389918088913,
0.07200388610363007,
-0.07452020049095154,
-0.07654763013124466,
-0.02355406992137432,
0.0086... | 0.020284 |
service discovery mechanisms, without being tied to Kubernetes' implementation. For headless Services, a cluster IP is not allocated, kube-proxy does not handle these Services, and there is no load balancing or proxying done by the platform for them. A headless Service allows a client to connect to whichever Pod it pre... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/service.md | main | kubernetes | [
-0.0065018790774047375,
-0.003827215638011694,
0.050708480179309845,
-0.008539876900613308,
-0.08514638245105743,
-0.0005259021418169141,
-0.02498285099864006,
-0.0342685803771019,
0.09347027540206909,
0.047639839351177216,
-0.03245503827929497,
-0.0024881355930119753,
-0.025952879339456558,... | 0.176632 |
by their DNS name. For example, if you have a Service called `my-service` in a Kubernetes namespace `my-ns`, the control plane and the DNS Service acting together create a DNS record for `my-service.my-ns`. Pods in the `my-ns` namespace should be able to find the service by doing a name lookup for `my-service` (`my-ser... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/service.md | main | kubernetes | [
-0.01726681925356388,
-0.060817040503025055,
0.031088873744010925,
-0.03906109929084778,
-0.08577964454889297,
-0.013120487332344055,
-0.006232846528291702,
-0.030600525438785553,
0.09892591834068298,
0.04284689947962761,
-0.051815684884786606,
-0.056881386786699295,
-0.006039909552782774,
... | 0.158421 |
"version" >}}/#service-v1-core). ## {{% heading "whatsnext" %}} Learn more about Services and how they fit into Kubernetes: \* Follow the [Connecting Applications with Services](/docs/tutorials/services/connect-applications-service/) tutorial. \* Read about [Ingress](/docs/concepts/services-networking/ingress/), which ... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/service.md | main | kubernetes | [
-0.004121173173189163,
-0.0061689214780926704,
0.021518981084227562,
-0.028147749602794647,
-0.0376351922750473,
0.020960113033652306,
-0.005403234623372555,
0.03917858004570007,
0.03202344477176666,
0.05330023914575577,
-0.04868410527706146,
-0.00887432973831892,
0.003895124886184931,
-0.... | 0.247924 |
{{< feature-state for\_k8s\_version="v1.23" state="beta" >}} {{< note >}} Prior to Kubernetes 1.27, this feature was known as \_Topology Aware Hints\_. {{}} \_Topology Aware Routing\_ adjusts routing behavior to prefer keeping traffic in the zone it originated from. In some cases this can help reduce costs or improve n... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/topology-aware-routing.md | main | kubernetes | [
-0.016779303550720215,
-0.044925421476364136,
0.05672956258058548,
0.025084948167204857,
-0.0001758920116117224,
0.030214598402380943,
0.08224525302648544,
-0.020677000284194946,
0.09260022640228271,
0.013481566682457924,
-0.03334709629416466,
-0.01828165352344513,
-0.008183577097952366,
-... | 0.162254 |
would result in some traffic being routed to other zones. ## Safeguards The Kubernetes control plane and the kube-proxy on each node apply some safeguard rules before using Topology Aware Hints. If these don't check out, the kube-proxy selects endpoints from anywhere in your cluster, regardless of the zone. 1. \*\*Insu... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/topology-aware-routing.md | main | kubernetes | [
0.04007275402545929,
-0.03439491242170334,
0.01724793203175068,
0.0025859959423542023,
0.0096685029566288,
0.022516127675771713,
-0.0006114662392064929,
-0.031204456463456154,
0.08378901332616806,
0.06481412798166275,
-0.10518420487642288,
-0.056167472153902054,
-0.020096709951758385,
-0.0... | 0.110551 |
is deployed in many different ways, there is no single heuristic for allocating endpoints to zones will work for every use case. A key goal of this feature is to enable custom heuristics to be developed if the built in heuristic does not work for your use case. The first steps to enable custom heuristics were included ... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/topology-aware-routing.md | main | kubernetes | [
0.06467735767364502,
-0.022649426013231277,
-0.034616727381944656,
-0.084922656416893,
-0.049353912472724915,
0.0056010824628174305,
0.028286291286349297,
0.012710490263998508,
0.022806264460086823,
0.0863180086016655,
-0.0830225795507431,
-0.054568786174058914,
0.024203645065426826,
0.002... | 0.125598 |
Kubernetes supports running nodes on either Linux or Windows. You can mix both kinds of node within a single cluster. This page provides an overview to networking specific to the Windows operating system. ## Container networking on Windows {#networking} Networking for Windows containers is exposed through [CNI plugins]... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/windows-networking.md | main | kubernetes | [
0.040044691413640976,
0.017419040203094482,
-0.007617529481649399,
-0.009814214892685413,
-0.04020727053284645,
0.055042803287506104,
-0.009688830934464931,
-0.028026577085256577,
0.05048783868551254,
0.029739607125520706,
-0.0684860497713089,
-0.04237842559814453,
-0.021684447303414345,
-... | 0.200544 |
[win-overlay](https://www.cni.dev/plugins/current/main/win-overlay/), [Flannel VXLAN](https://github.com/flannel-io/flannel/blob/master/Documentation/backends.md#vxlan) (uses win-overlay) | win-overlay should be used when virtual container networks are desired to be isolated from underlay of hosts (e.g. for security re... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/windows-networking.md | main | kubernetes | [
-0.04223087057471275,
0.021567536517977715,
-0.02408631145954132,
-0.011767496354877949,
0.08355394750833511,
0.005023513454943895,
-0.010288076475262642,
-0.011305811814963818,
-0.0271603986620903,
-0.016638806089758873,
0.02205146662890911,
0.009411404840648174,
-0.030307188630104065,
-0... | 0.02972 |
Service: \* `NodePort` \* `ClusterIP` \* `LoadBalancer` \* `ExternalName` Windows container networking differs in some important ways from Linux networking. The [Microsoft documentation for Windows Container Networking](https://docs.microsoft.com/en-us/virtualization/windowscontainers/container-networking/architecture)... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/windows-networking.md | main | kubernetes | [
-0.05410194396972656,
-0.001527532353065908,
-0.03219174966216087,
0.0012991916155442595,
-0.05891401320695877,
0.022861534729599953,
0.020230818539857864,
-0.002642803592607379,
-0.00702710822224617,
0.035667967051267624,
-0.05325065925717354,
-0.004219169728457928,
-0.011698625981807709,
... | 0.096069 |
{{< feature-state for\_k8s\_version="v1.19" state="stable" >}} {{< glossary\_definition term\_id="ingress" length="all" >}} {{< note >}} The Kubernetes project recommends using [Gateway](https://gateway-api.sigs.k8s.io/) instead of [Ingress](/docs/concepts/services-networking/ingress/). The Ingress API has been frozen.... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/ingress.md | main | kubernetes | [
-0.05200319364666939,
0.031376682221889496,
0.08450838178396225,
0.0008818685892038047,
-0.0039529805071651936,
-0.005672886501997709,
-0.020835814997553825,
-0.03573870286345482,
0.032264143228530884,
0.050645194947719574,
0.01093367300927639,
-0.010685551911592484,
-0.02934715896844864,
... | 0.20923 |
the `ingressClassName` is omitted, a [default Ingress class](#default-ingress-class) should be defined. Some ingress controllers work even without the definition of a default IngressClass. Even if you use an ingress controller that is able to operate without any IngressClass, the Kubernetes project still recommends tha... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/ingress.md | main | kubernetes | [
-0.0780380591750145,
0.01689717546105385,
0.0471869520843029,
-0.05882062762975693,
-0.04147448390722275,
-0.028073148801922798,
0.06887312233448029,
-0.0446326769888401,
0.057739779353141785,
0.04767072573304176,
-0.023119064047932625,
-0.025922372937202454,
0.014338981360197067,
-0.04658... | 0.153249 |
A path element refers to the list of labels in the path split by the `/` separator. A request is a match for path \_p\_ if every \_p\_ is an element-wise prefix of \_p\_ of the request path. {{< note >}} If the last element of the path is a substring of the last element in request path, it is not a match (for example: ... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/ingress.md | main | kubernetes | [
-0.059509601444005966,
0.05020882189273834,
0.10571525245904922,
0.008449628949165344,
-0.0147283049300313,
-0.007523278705775738,
0.0157475583255291,
0.03272806853055954,
0.039644405245780945,
-0.04314423352479935,
-0.035049472004175186,
-0.0009935343405231833,
0.009145760908722878,
-0.00... | 0.012211 |
{{< tabs name="tabs\_ingressclass\_parameter\_scope" >}} {{% tab name="Cluster" %}} The default scope for IngressClass parameters is cluster-wide. If you set the `.spec.parameters` field and don't set `.spec.parameters.scope`, or if you set `.spec.parameters.scope` to `Cluster`, then the IngressClass refers to a cluste... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/ingress.md | main | kubernetes | [
-0.03310904651880264,
0.023427192121744156,
-0.028156818822026253,
0.06436021625995636,
0.014819297008216381,
0.032110679894685745,
0.05252707004547119,
-0.021399904042482376,
-0.01653786189854145,
0.01851618103682995,
-0.012844329699873924,
-0.0860043540596962,
-0.0030282256193459034,
0.0... | 0.186691 |
as default in your cluster. {{< /caution >}} Start by defining a default IngressClass. It is recommended though, to specify the default IngressClass: {{% code\_sample file="service/networking/default-ingressclass.yaml" %}} ## Types of Ingress ### Ingress backed by a single Service {#single-service-ingress} There are ex... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/ingress.md | main | kubernetes | [
-0.012005100026726723,
0.005495742429047823,
0.007400846108794212,
0.011070377193391323,
-0.01953122951090336,
0.011158694513142109,
0.017854319885373116,
0.011979787610471249,
0.015306497924029827,
0.060693494975566864,
-0.03191160410642624,
-0.06471172720193863,
0.013211144134402275,
-0.... | 0.154778 |
controller supports SNI). The TLS secret must contain keys named `tls.crt` and `tls.key` that contain the certificate and private key to use for TLS. For example: ```yaml apiVersion: v1 kind: Secret metadata: name: testsecret-tls namespace: default data: tls.crt: base64 encoded cert tls.key: base64 encoded key type: ku... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/ingress.md | main | kubernetes | [
-0.03911970928311348,
0.07604565471410751,
-0.012935042381286621,
0.009014938026666641,
-0.03443304821848869,
-0.020637135952711105,
0.004247423727065325,
-0.00909089483320713,
0.12612015008926392,
0.07873725146055222,
-0.02148757129907608,
-0.11167161911725998,
0.020794346928596497,
0.041... | 0.038745 |
details. ## Alternatives You can expose a Service in multiple ways that don't directly involve the Ingress resource: \* Use [Service.Type=LoadBalancer](/docs/concepts/services-networking/service/#loadbalancer) \* Use [Service.Type=NodePort](/docs/concepts/services-networking/service/#type-nodeport) ## {{% heading "what... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/ingress.md | main | kubernetes | [
-0.08276408165693283,
0.028456706553697586,
0.0007959122303873301,
0.012490923516452312,
-0.0036824073176831007,
-0.007122172974050045,
0.03989144414663315,
0.034092508256435394,
0.034827083349227905,
0.037698496133089066,
-0.03329738974571228,
-0.015233771875500679,
0.02332116849720478,
-... | 0.223383 |
## The Kubernetes network model The Kubernetes network model is built out of several pieces: \* Each [pod](/docs/concepts/workloads/pods/) in a cluster gets its own unique cluster-wide IP address. \* A pod has its own private network namespace which is shared by all of the containers within the pod. Processes running i... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/_index.md | main | kubernetes | [
0.013190066441893578,
-0.015454589389264584,
0.01741638034582138,
-0.022694049403071404,
-0.0015809455653652549,
0.011483530513942242,
0.0447680689394474,
-0.05693245679140091,
0.09331093728542328,
0.018519742414355278,
-0.006720849312841892,
-0.0014436331111937761,
0.007546625565737486,
-... | 0.28602 |
be present, but it will have no effect.) \* There are many [implementations of the Gateway API](https://gateway-api.sigs.k8s.io/implementations/), some of which are specific to particular cloud environments, some more focused on "bare metal" environments, and others more generic. ## {{% heading "whatsnext" %}} The [Con... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/_index.md | main | kubernetes | [
-0.009587508626282215,
-0.023642636835575104,
0.021781377494335175,
0.007066164165735245,
-0.07140275090932846,
0.028096798807382584,
-0.030064284801483154,
0.003226189175620675,
0.028633389621973038,
0.012895324267446995,
-0.05637768283486366,
0.027612673118710518,
0.02002461440861225,
-0... | 0.22918 |
Kubernetes creates DNS records for Services and Pods. You can contact Services with consistent DNS names instead of IP addresses. Kubernetes publishes information about Pods and Services which is used to program DNS. kubelet configures Pods' DNS so that running containers can look up Services by name rather than IP. Se... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/dns-pod-service.md | main | kubernetes | [
-0.009092998690903187,
-0.05685044825077057,
0.08571381866931915,
-0.007259668782353401,
-0.0828048586845398,
-0.026591459289193153,
-0.008885516785085201,
-0.04681535065174103,
0.15199561417102814,
0.009930480271577835,
-0.042489852756261826,
-0.021615304052829742,
-0.004351576790213585,
... | 0.151996 |
a Pod in the `cafe` namespace has the IP address 172.17.0.3, is an endpoint of a Service named `barista`, and the domain name for your cluster is `cluster.local`, then the Pod would have this service-scoped DNS `A` record. ``` 172-17-0-3.barista.cafe.svc.cluster.local ``` ### Pod's hostname and subdomain fields {#pod-h... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/dns-pod-service.md | main | kubernetes | [
0.007510020397603512,
-0.033166706562042236,
0.005709060467779636,
0.025546174496412277,
-0.0022355488035827875,
-0.06519795954227448,
0.005568753927946091,
-0.024823397397994995,
0.061596017330884933,
0.00318063679151237,
-0.0387875959277153,
-0.0494295135140419,
0.004151960369199514,
-0.... | 0.19091 |
the kernel (the `nodename` field of `struct utsname`) is limited to 64 characters. If a Pod enables this feature and its FQDN is longer than 64 character, it will fail to start. The Pod will remain in `Pending` status (`ContainerCreating` as seen by `kubectl`) generating error events, such as Failed to construct FQDN f... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/dns-pod-service.md | main | kubernetes | [
0.013169187121093273,
0.02129116654396057,
-0.0011787933763116598,
-0.03884501755237579,
-0.07219447195529938,
-0.02609723061323166,
-0.03190263360738754,
-0.00024092465173453093,
0.03389820456504822,
0.040217943489551544,
0.0006621740176342428,
-0.04411035403609276,
0.004570082761347294,
... | 0.131455 |
32 search domains. - `options`: an optional list of objects where each object may have a `name` property (required) and a `value` property (optional). The contents in this property will be merged to the options generated from the specified DNS policy. Duplicate entries are removed. The following is an example Pod with ... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/services-networking/dns-pod-service.md | main | kubernetes | [
-0.0071593825705349445,
0.010810569860041142,
0.009869151748716831,
-0.0057246629148721695,
-0.07516303658485413,
-0.04896732047200203,
-0.03371444717049599,
-0.04547512158751488,
0.09429918229579926,
0.012666990049183369,
-0.02445380575954914,
-0.0529094822704792,
-0.054339759051799774,
-... | 0.112673 |
You've deployed your application and exposed it via a Service. Now what? Kubernetes provides a number of tools to help you manage your application deployment, including scaling and updating. ## Organizing resource configurations Many applications require multiple resources to be created, such as a Deployment along with... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/management.md | main | kubernetes | [
-0.024295929819345474,
-0.00355789577588439,
0.016972551122307777,
0.0017328208778053522,
-0.05263135954737663,
-0.013384640216827393,
0.010869761928915977,
0.0074875676073133945,
0.1102997362613678,
0.03647274896502495,
-0.06764162331819534,
-0.016773981973528862,
0.0007219490362331271,
0... | 0.064752 |
``` With the above commands, first you create resources under `docs/concepts/cluster-administration/nginx/` and print the resources created with `-o name` output format (print each resource as resource/name). Then you `grep` only the Service, and then print it with [`kubectl get`](/docs/reference/kubectl/generated/kube... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/management.md | main | kubernetes | [
-0.0596601702272892,
0.04524252191185951,
0.005502379033714533,
0.003830353496596217,
-0.020855523645877838,
-0.05000688135623932,
0.0371612012386322,
-0.05309530347585678,
0.05687590315937996,
0.003745708614587784,
-0.009424020536243916,
-0.0854000672698021,
0.02476242370903492,
0.0100019... | 0.081291 |
### Managing rollouts You can use [`kubectl rollout`](/docs/reference/kubectl/generated/kubectl\_rollout/) to manage a progressive update of an existing application. For example: ```shell kubectl apply -f my-deployment.yaml # wait for rollout to finish kubectl rollout status deployment/my-deployment --timeout 10m # 10 ... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/management.md | main | kubernetes | [
0.05471264198422432,
-0.007392875850200653,
0.015139790251851082,
-0.024966731667518616,
-0.02817121334373951,
-0.0037581028882414103,
-0.05517268180847168,
-0.044643107801675797,
0.07054761797189713,
0.027063073590397835,
0.015206430107355118,
-0.013073228299617767,
-0.025772714987397194,
... | 0.090383 |
resources you've created. ### kubectl apply It is suggested to maintain a set of configuration files in source control (see [configuration as code](https://martinfowler.com/bliki/InfrastructureAsCode.html)), so that they can be maintained and versioned along with the code for the resources they configure. Then, you can... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/management.md | main | kubernetes | [
-0.017150012776255608,
0.010478782467544079,
0.05144495517015457,
0.008921965956687927,
-0.027357397601008415,
-0.0200608242303133,
-0.06091630831360817,
-0.04250495508313179,
0.012989301234483719,
0.028245242312550545,
-0.027957884594798088,
-0.032102085649967194,
-0.02084285393357277,
-0... | 0.029846 |
In Kubernetes, you can \_scale\_ a workload depending on the current demand of resources. This allows your cluster to react to changes in resource demand more elastically and efficiently. When you scale a workload, you can either increase or decrease the number of replicas managed by the workload, or adjust the resourc... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/autoscaling.md | main | kubernetes | [
0.014799495227634907,
0.005893712863326073,
0.011834044009447098,
-0.008219894953072071,
-0.09987747669219971,
-0.024335741996765137,
-0.058397646993398666,
0.006059873383492231,
0.05423521623015404,
0.022823354229331017,
-0.06481651961803436,
-0.0019315272802487016,
0.002256805310025811,
... | 0.14867 |
a workload (for example a Deployment or DaemonSet) based on the number of nodes and/or cores in the cluster. ### Event driven Autoscaling It is also possible to scale workloads based on events, for example using the [\_Kubernetes Event Driven Autoscaler\_ (\*\*KEDA\*\*)](https://keda.sh/). KEDA is a CNCF-graduated proj... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/autoscaling.md | main | kubernetes | [
-0.01259652990847826,
0.01512089278548956,
-0.013109249994158745,
0.038956575095653534,
-0.05716428533196449,
-0.03967560455203056,
0.0005170917138457298,
0.0042755259200930595,
0.0492839515209198,
0.013942539691925049,
-0.06812804192304611,
-0.06654199212789536,
-0.02340482920408249,
-0.0... | 0.213163 |
{{< glossary\_definition term\_id="workload" length="short" >}} Whether your workload is a single component or several that work together, on Kubernetes you run it inside a set of [\_pods\_](/docs/concepts/workloads/pods). In Kubernetes, a Pod represents a set of running {{< glossary\_tooltip text="containers" term\_id... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/_index.md | main | kubernetes | [
-0.02081194519996643,
-0.018387602642178535,
0.11495191603899002,
0.04076332226395607,
-0.0014276859583333135,
-0.02621697448194027,
0.029579952359199524,
-0.027863476425409317,
0.05410896986722946,
0.030073193833231926,
0.00016373411926906556,
-0.04328408092260361,
-0.013885469175875187,
... | 0.133864 |
Pods and apply advanced scheduling policies to them, such as [gang scheduling](/docs/concepts/scheduling-eviction/gang-scheduling/). This is particularly useful for batch processing and machine learning workloads where "all-or-nothing" placement is required. ## {{% heading "whatsnext" %}} As well as reading about each ... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/_index.md | main | kubernetes | [
-0.018906623125076294,
-0.023669514805078506,
0.03341629356145859,
0.01306998822838068,
-0.05577922239899635,
-0.02976214699447155,
-0.051836512982845306,
-0.03305850923061371,
-0.018966399133205414,
0.052951887249946594,
-0.05741976574063301,
-0.013489248231053352,
0.0013858542079105973,
... | 0.169976 |
{{< feature-state feature\_gate\_name="GenericWorkload" >}} Every pod group defined in a [Workload](/docs/concepts/workloads/workload-api/) must declare a scheduling policy. This policy dictates how the scheduler treats the collection of Pods. ## Policy types The API currently supports two policy types: `basic` and `ga... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/workload-api/policies.md | main | kubernetes | [
-0.026363519951701164,
0.014112441800534725,
0.05954653024673462,
0.01607844978570938,
-0.0035244321916252375,
-0.02653946913778782,
-0.026013245806097984,
-0.03374145179986954,
0.04440092667937279,
0.04793134331703186,
-0.027458613738417625,
0.005137496627867222,
-0.03535314276814461,
0.0... | 0.192447 |
{{< feature-state feature\_gate\_name="GenericWorkload" >}} The Workload API resource allows you to describe the scheduling requirements and structure of a multi-Pod application. While workload controllers provide runtime behavior for the workloads, the Workload API is supposed to provide scheduling constraints for the... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/workload-api/_index.md | main | kubernetes | [
-0.0567292757332325,
-0.0061425440944731236,
0.032403506338596344,
0.0544547513127327,
-0.04973126947879791,
-0.04959782212972641,
-0.03428564965724945,
-0.03487895056605339,
0.002783609554171562,
0.03519321233034134,
-0.07177617400884628,
-0.06809834390878677,
-0.042668670415878296,
0.005... | 0.17257 |
{{< feature-state for\_k8s\_version="v1.30" state="beta" >}} This page explains how user namespaces are used in Kubernetes pods. A user namespace isolates the user running inside the container from the one in the host. A process running as root in a container can run as a different (non-root) user in the host; in other... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/pods/user-namespaces.md | main | kubernetes | [
-0.0036570520605891943,
0.03647323325276375,
0.07332172989845276,
-0.005300756078213453,
-0.019982168450951576,
-0.029281679540872574,
0.031741537153720856,
-0.003540041856467724,
0.04671923443675041,
0.03494946286082268,
-0.031997695565223694,
-0.038486696779727936,
0.0031160868238657713,
... | 0.186396 |
the inodes created/read in volumes mounted by the pod will be the same as if the pod wasn't using user namespaces. This way, a pod can easily enable and disable user namespaces (without affecting its volume's file ownerships) and can also share volumes with pods without user namespaces by just setting the appropriate u... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/pods/user-namespaces.md | main | kubernetes | [
-0.013490971177816391,
-0.06294993311166763,
0.020341766998171806,
0.023696882650256157,
-0.023346511647105217,
-0.07915538549423218,
-0.02893899939954281,
0.05395293980836868,
0.07540865987539291,
0.06234057992696762,
0.017820393666625023,
0.05764451250433922,
0.006604320369660854,
-0.002... | 0.133241 |
if some capability were granted to the container, the capabilities are valid on the host too. None of this is true when we use user namespaces. If you want to know more details about what changes when user namespaces are in use, see `man 7 user\_namespaces`. ## Set up a node to support user namespaces By default, the k... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/pods/user-namespaces.md | main | kubernetes | [
-0.01566590741276741,
0.02124134637415409,
0.037494122982025146,
-0.017652319744229317,
-0.05407290533185005,
-0.03850250691175461,
-0.004861255642026663,
-0.014094246551394463,
0.06863383203744888,
-0.01758349873125553,
-0.003709109267219901,
-0.049301326274871826,
-0.005284893326461315,
... | 0.146234 |
`KubeletConfiguration`. Running containers are not affected by this config. In Kubernetes prior to v1.33, the ID count for each of Pods was hard-coded to 65536. ## Integration with Pod security admission checks {{< feature-state state="alpha" for\_k8s\_version="v1.29" >}} For Linux Pods that enable user namespaces, Kub... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/pods/user-namespaces.md | main | kubernetes | [
0.06135464087128639,
0.014877554960548878,
0.04268428310751915,
-0.005723797250539064,
-0.005373661871999502,
-0.015595538541674614,
0.025656258687376976,
-0.01572808064520359,
0.04122108593583107,
0.00042754533933475614,
-0.003543322207406163,
-0.05985359847545624,
0.04193824157118797,
-0... | 0.134125 |
{{< feature-state feature\_gate\_name="SidecarContainers" >}} Sidecar containers are the secondary containers that run along with the main application container within the same {{< glossary\_tooltip text="Pod" term\_id="pod" >}}. These containers are used to enhance or to extend the functionality of the primary \_app c... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/pods/sidecar-containers.md | main | kubernetes | [
-0.000015711642845417373,
0.02035168558359146,
0.05697260797023773,
0.011072362773120403,
0.040478188544511795,
-0.033081695437431335,
0.011661270633339882,
-0.0052221897058188915,
0.015149836428463459,
-0.007300789467990398,
0.056211963295936584,
0.001434938283637166,
-0.038892801851034164,... | 0.198636 |
stopped. The sidecar containers are then shut down in the opposite order of their appearance in the Pod specification. This approach ensures that the sidecars remain operational, supporting other containers within the Pod, until their service is no longer required. ### Jobs with sidecar containers If you define a Job t... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/pods/sidecar-containers.md | main | kubernetes | [
0.005533896386623383,
0.03347184509038925,
0.04762440174818039,
0.007648903410881758,
0.03433878347277641,
-0.01501341350376606,
-0.04794614762067795,
-0.06035037711262703,
-0.011664665304124355,
0.026824036613106728,
0.041434723883867264,
0.06706331670284271,
-0.06007738783955574,
-0.0552... | 0.132945 |
(quality of service) tier of the Pod's \*effective QoS tier\* is the QoS tier for all init, sidecar and app containers alike. Quota and limits are applied based on the effective Pod request and limit. ### Sidecar containers and Linux cgroups {#cgroups} On Linux, resource allocations for Pod level control groups (cgroup... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/pods/sidecar-containers.md | main | kubernetes | [
-0.0067278011702001095,
0.047315698117017746,
-0.00475001335144043,
0.013763893395662308,
0.0002296594757353887,
-0.04422872141003609,
0.000476051471196115,
0.058710429817438126,
-0.018474888056516647,
0.011552697978913784,
-0.0006266978452913463,
-0.01351828034967184,
-0.01653936319053173,
... | 0.214016 |
{{< feature-state feature\_gate\_name="GenericWorkload" >}} You can link a Pod to a [Workload](/docs/concepts/workloads/workload-api/) object to indicate that the Pod belongs to a larger application or group. This enables the scheduler to make decisions based on the group's requirements rather than treating the Pod as ... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/pods/workload-reference.md | main | kubernetes | [
-0.022405555471777916,
-0.019316142424941063,
0.032831162214279175,
0.08846572041511536,
0.02349768951535225,
-0.02891295775771141,
-0.005301105789840221,
-0.023430895060300827,
0.009659218601882458,
-0.0030133589170873165,
-0.06578335165977478,
-0.03503170609474182,
-0.06051401421427727,
... | 0.178536 |
It is sometimes useful for a container to have information about itself, without being overly coupled to Kubernetes. The \_downward API\_ allows containers to consume information about themselves or the cluster without using the Kubernetes client or API server. An example is an existing application that assumes a parti... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/pods/downward-api.md | main | kubernetes | [
0.0061150770634412766,
0.06540414690971375,
0.04535006359219551,
0.03056957572698593,
-0.018444476649165154,
-0.06082707270979881,
-0.00428905850276351,
0.013835910707712173,
0.08755030483007431,
0.0064729610458016396,
-0.047956522554159164,
-0.04524807259440422,
0.040652722120285034,
-0.0... | 0.179488 |
`resource: limits.hugepages-\*` : A container's hugepages limit `resource: requests.hugepages-\*` : A container's hugepages request `resource: limits.ephemeral-storage` : A container's ephemeral-storage limit `resource: requests.ephemeral-storage` : A container's ephemeral-storage request #### Fallback information for ... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/pods/downward-api.md | main | kubernetes | [
0.030479809269309044,
0.09756410866975784,
-0.009859176352620125,
0.03031260147690773,
-0.07366941124200821,
-0.04541321471333504,
-0.04329000040888786,
0.03452177345752716,
0.027970774099230766,
0.025008123368024826,
-0.04504866898059845,
-0.072198286652565,
-0.008888800628483295,
-0.0482... | 0.153105 |
This page describes the lifecycle of a Pod. Pods follow a defined lifecycle, starting in the `Pending` [phase](#pod-phase), moving through `Running` if at least one of its primary containers starts OK, and then through either the `Succeeded` or `Failed` phases depending on whether any container in the Pod terminated in... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/pods/pod-lifecycle.md | main | kubernetes | [
-0.03800521045923233,
-0.016960468143224716,
0.06316963583230972,
0.03200783580541611,
0.04350360482931137,
-0.04618661105632782,
0.008367474190890789,
-0.03867928683757782,
0.11751095950603485,
0.04394035041332245,
0.03177683427929878,
0.03850056231021881,
-0.013945314101874828,
-0.045532... | 0.252082 |
Pod. Kubernetes does not guarantee that a replacement for an existing Pod would be scheduled to the same node as the old Pod that was being replaced. ### Associated lifetimes When something is said to have the same lifetime as a Pod, such as a {{< glossary\_tooltip term\_id="volume" text="volume" >}}, that means that t... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/pods/pod-lifecycle.md | main | kubernetes | [
-0.04911266267299652,
0.003105448791757226,
0.13381905853748322,
0.0143220080062747,
0.05578475818037987,
-0.048364054411649704,
-0.02269870787858963,
-0.06013500690460205,
0.12308084964752197,
0.019360780715942383,
0.029931604862213135,
0.03125610575079918,
-0.014595516957342625,
-0.03432... | 0.108205 |
the exit statuses of the pod containers) before their deletion from the API server. If a node dies or is disconnected from the rest of the cluster, Kubernetes applies a policy for setting the `phase` of all Pods on the lost node to Failed. ## Container states As well as the [phase](#pod-phase) of the Pod overall, Kuber... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/pods/pod-lifecycle.md | main | kubernetes | [
-0.011081905104219913,
-0.008757553063333035,
0.07179098576307297,
0.047062236815690994,
0.027074186131358147,
-0.02271963283419609,
0.013050043024122715,
-0.10199621319770813,
0.10192090272903442,
0.029183601960539818,
-0.030319495126605034,
-0.03979972004890442,
-0.0066965059377253056,
-... | 0.131631 |
In other words, when a container enters the crash loop, Kubernetes applies the exponential backoff delay mentioned in the [Container restart policy](#restart-policy). This mechanism prevents a faulty container from overwhelming the system with continuous failed start attempts. The `CrashLoopBackOff` can be caused by is... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/pods/pod-lifecycle.md | main | kubernetes | [
0.07019662857055664,
0.014952111057937145,
0.06776176393032074,
0.004654991906136274,
0.02824815921485424,
0.012890302576124668,
-0.012017003260552883,
0.01978130079805851,
0.04535776376724243,
0.053944434970617294,
-0.045774560421705246,
-0.01050456240773201,
-0.03721129521727562,
-0.0346... | 0.077215 |
| |-----------|-------------------------|---------------------------|------------------------|-------------------| | 0 (Success) | Restarts | Does not restart | Does not restart | Always restarts | | Non-zero (Failure) | Restarts | Restarts | Does not restart | Always restarts | {{< note >}} The restart behavior is par... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/pods/pod-lifecycle.md | main | kubernetes | [
-0.07532373070716858,
-0.07002592086791992,
-0.07013789564371109,
0.012187937274575233,
-0.0005532400100491941,
-0.02874395065009594,
-0.005699438508599997,
-0.026830002665519714,
-0.04545827582478523,
0.013528420589864254,
0.06829100102186203,
0.03269697725772858,
0.0076861875131726265,
-... | 0.129222 |
the behaviour of `init containers` when specify `restartPolicy` field on it. #### Individual container restart policy and rules {#container-restart-rules} {{< feature-state feature\_gate\_name="ContainerRestartRules" >}} If your cluster has the feature gate `ContainerRestartRules` enabled, you can specify `restartPolic... | https://github.com/kubernetes/website/blob/main//content/en/docs/concepts/workloads/pods/pod-lifecycle.md | main | kubernetes | [
0.02827443741261959,
-0.014924803748726845,
0.05349472165107727,
0.03760470822453499,
-0.0031893544364720583,
0.002005176618695259,
0.00048731573042459786,
-0.046639859676361084,
-0.03413736820220947,
0.029489949345588684,
0.005541951861232519,
0.015384555794298649,
-0.037724245339632034,
... | 0.084555 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.