content large_stringlengths 3 20.5k | url large_stringlengths 53 192 ⌀ | branch large_stringclasses 4
values | source large_stringclasses 50
values | embeddings listlengths 384 384 | score float64 -0.21 0.65 |
|---|---|---|---|---|---|
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 one or more running {{< glossary\_tooltip text="containe... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/_index.md | main | kubernetes | [
-0.009138955734670162,
-0.01363346353173256,
0.11246401816606522,
0.0435471311211586,
0.006045523099601269,
-0.02650480344891548,
0.024978958070278168,
-0.019527003169059753,
0.060802608728408813,
0.033394262194633484,
0.0026219228748232126,
-0.03665291145443916,
-0.01694902963936329,
-0.0... | 0.148192 |
`PodGroupTemplates` to group Pods and apply advanced scheduling policies to them, such as [gang scheduling](/docs/concepts/scheduling-eviction/gang-scheduling/). Controllers create [PodGroup](/docs/concepts/workloads/podgroup-api/) objects from these templates at runtime, and `Pods` reference their `PodGroup` via the `... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/_index.md | main | kubernetes | [
-0.0053614601492881775,
-0.01812247931957245,
-0.004229401703923941,
0.05000387504696846,
-0.05669858306646347,
-0.023130616173148155,
-0.03989429026842117,
-0.0049045695923268795,
-0.005197634920477867,
0.043211981654167175,
-0.03251095116138458,
0.009537488222122192,
-0.025342155247926712,... | 0.165987 |
{{< feature-state feature\_gate\_name="GenericWorkload" >}} Every [PodGroup](/docs/concepts/workloads/podgroup-api/) must declare a scheduling policy in its `spec.schedulingPolicy` field. This policy dictates how the scheduler treats the collection of Pods in the group. ## Policy types The `schedulingPolicy` field supp... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/workload-api/policies.md | main | kubernetes | [
-0.03168453276157379,
-0.015328474342823029,
0.01885518804192543,
0.04884624108672142,
0.0019353949464857578,
-0.03745153173804283,
-0.03269396722316742,
-0.009264483116567135,
-0.009815284051001072,
0.036815766245126724,
-0.0320793092250824,
0.029974455013871193,
-0.025533268228173256,
0.... | 0.179396 |
{{< feature-state feature\_gate\_name="TopologyAwareWorkloadScheduling" >}} \*Topology-Aware Scheduling\* (TAS) is a feature of the Workload API that optimizes the placement of pods within the cluster. TAS ensures that all pods within a PodGroup are co-located into a specific topology domain, such as a single server ra... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/workload-api/topology-aware-scheduling.md | main | kubernetes | [
-0.015575509518384933,
-0.028805216774344444,
0.019269771873950958,
0.07226115465164185,
0.009545751847326756,
-0.06421447545289993,
-0.005336597561836243,
-0.01590346358716488,
0.050585489720106125,
0.03480059653520584,
-0.009645042009651661,
-0.00407422287389636,
-0.016508352011442184,
-... | 0.251474 |
- key: topology.example.com/rack ``` ## {{% heading "whatsnext" %}} \* Learn about [pod group policies](/docs/concepts/workloads/workload-api/policies/). \* Learn about [plugins related Topology-aware Scheduling](/docs/concepts/scheduling-eviction/topology-aware-scheduling/) \* Read about [gang scheduling](/docs/concep... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/workload-api/topology-aware-scheduling.md | main | kubernetes | [
0.013142462819814682,
0.03144567087292671,
-0.0649692714214325,
0.025235535576939583,
-0.016495728865265846,
-0.04095761850476265,
0.041512537747621536,
-0.021516593173146248,
-0.04291289299726486,
0.022318456321954727,
-0.013919946737587452,
0.0880689024925232,
0.028427833691239357,
0.002... | 0.161271 |
{{< feature-state feature\_gate\_name="WorkloadAwarePreemption" >}} PodGroup can declare a disruption mode. This mode dictates how the scheduler can disrupt a running PodGroup, for example to accommodate a higher priority PodGroup. A PodGroup also has a priority, which overrides the priority of the individual pods from... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/workload-api/disruption-and-priority.md | main | kubernetes | [
-0.015421595424413681,
0.0003324608551338315,
0.0749407634139061,
0.09290168434381485,
0.04350933060050011,
-0.036475758999586105,
-0.0192219540476799,
-0.013575789518654346,
0.029100321233272552,
0.03364603593945503,
-0.008610496297478676,
0.03988219425082207,
-0.07930731773376465,
0.0466... | 0.180448 |
{{< feature-state feature\_gate\_name="GenericWorkload" >}} The `Workload` API resource defines the scheduling requirements and structure of a multi-Pod application. While workload controllers such as [Job](/docs/concepts/workloads/controllers/job/) manage the application's runtime state, the `Workload` specifies how g... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/workload-api/_index.md | main | kubernetes | [
-0.045564595609903336,
-0.004381451290100813,
0.01477041095495224,
0.08152548968791962,
-0.03302647918462753,
-0.011571105569601059,
-0.037667423486709595,
-0.03471161052584648,
0.018823198974132538,
0.02599404938519001,
-0.04015277326107025,
-0.04622260108590126,
-0.03972228616476059,
0.0... | 0.153419 |
the [gang scheduling](/docs/concepts/scheduling-eviction/gang-scheduling/) algorithm. | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/workload-api/_index.md | main | kubernetes | [
-0.1003849133849144,
0.06548915058374405,
-0.05893411114811897,
-0.016771409660577774,
-0.03601410239934921,
-0.08506949245929718,
-0.036434341222047806,
-0.059106454253196716,
-0.03039919026196003,
0.058880895376205444,
0.027431467548012733,
0.12213505804538727,
0.025254961103200912,
-0.0... | 0.191361 |
{{< feature-state feature\_gate\_name="GenericWorkload" >}} A [PodGroup](/docs/concepts/workloads/podgroup-api/) is scheduled as a unit and protected from premature deletion while its Pods are still running. ## Ownership and lifecycle `PodGroups` are owned by the workload controller that created them (for example, a Jo... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/podgroup-api/lifecycle.md | main | kubernetes | [
-0.044506851583719254,
-0.02556200511753559,
0.009393777698278427,
0.042764030396938324,
-0.003192042000591755,
-0.05365057289600372,
0.019552312791347504,
-0.08244583010673523,
0.06498122215270996,
0.04182423651218414,
-0.00241859327070415,
0.021256055682897568,
-0.035439684987068176,
0.0... | 0.15474 |
{{< feature-state feature\_gate\_name="GenericWorkload" >}} A PodGroup is a runtime object that represents a group of Pods scheduled together as a single unit. While the [Workload API](/docs/concepts/workloads/workload-api/) defines scheduling policy templates, PodGroups are the runtime counterparts that carry both the... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/podgroup-api/_index.md | main | kubernetes | [
-0.05715722218155861,
0.016629796475172043,
0.04755476117134094,
0.0802171602845192,
-0.03946579992771149,
-0.024823971092700958,
-0.0006175262969918549,
-0.029668720439076424,
0.02622910775244236,
0.02245846949517727,
-0.04823797941207886,
-0.05845244228839874,
-0.031142449006438255,
0.02... | 0.173886 |
get podgroups ``` To see the full status including scheduling conditions: ```shell kubectl describe podgroup training-worker-0 ``` ## How it fits together The relationship between controllers, Workloads, PodGroups, and Pods follows this pattern: 1. The workload controller creates a Workload that defines PodGroupTemplat... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/podgroup-api/_index.md | main | kubernetes | [
-0.02250244840979576,
0.011915208771824837,
-0.016321886330842972,
0.04842593893408775,
-0.025862716138362885,
-0.002901725471019745,
-0.032431960105895996,
-0.05201788619160652,
0.057221513241529465,
0.029030077159404755,
-0.012952238321304321,
-0.03128813952207565,
-0.07306115329265594,
... | 0.167227 |
{{< feature-state feature\_gate\_name="UserNamespacesSupport" >}} 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 ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/user-namespaces.md | main | kubernetes | [
0.003924029413610697,
0.013592374511063099,
0.054338738322257996,
-0.00686302175745368,
-0.030606206506490707,
-0.04753458499908447,
0.028981877490878105,
-0.0058372789062559605,
0.04708268120884895,
0.03176471218466759,
-0.03085099533200264,
-0.03542178496718407,
0.007627133745700121,
-0.... | 0.186922 |
inside the container (`RunAsUser`, `RunAsGroup`, `fsGroup`, etc.). This applies to any volume the pod can mount, including `hostPath` (if the pod is allowed to mount `hostPath` volumes). By default, the valid UIDs/GIDs when this feature is enabled is the range 0-65535. This applies to files and processes (`runAsUser`, ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/user-namespaces.md | main | kubernetes | [
0.007542358245700598,
-0.04124733805656433,
-0.0036028458271175623,
-0.008834191597998142,
-0.0034149938728660345,
-0.09353592991828918,
-0.06276819109916687,
0.08314845710992813,
0.029513617977499962,
0.0447457917034626,
0.01676982082426548,
0.06701453775167465,
-0.0350346639752388,
-0.01... | 0.120121 |
namespaces By default, the kubelet assigns pods UIDs/GIDs above the range 0-65535, based on the assumption that the host's files and processes use UIDs/GIDs within this range, which is standard for most Linux distributions. This approach prevents any overlap between the UIDs/GIDs of the host and those of the pods. Avoi... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/user-namespaces.md | main | kubernetes | [
-0.002340716542676091,
-0.005306074861437082,
0.0305133368819952,
-0.01289120502769947,
-0.07362529635429382,
-0.035340599715709686,
-0.010598817840218544,
0.0007719587883912027,
0.09495719522237778,
0.012301015667617321,
-0.0039862049743533134,
-0.05617904290556908,
0.0021667275577783585,
... | 0.174669 |
a Pod that uses user namespaces, the following fields won't be constrained even in contexts that enforce the \_Baseline\_ or \_Restricted\_ pod security standard. This behavior does not present a security concern because `root` inside a Pod with user namespaces actually refers to the user inside the container, that is ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/user-namespaces.md | main | kubernetes | [
0.0686543807387352,
0.017907990142703056,
-0.036720722913742065,
-0.00320566282607615,
0.025860531255602837,
-0.06358473747968674,
0.07670556008815765,
0.011628180742263794,
0.018266135826706886,
0.022380050271749496,
0.039212167263031006,
-0.05031939968466759,
0.031959760934114456,
-0.012... | 0.130159 |
{{< 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 |
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 |
In Kubernetes, many objects have \_conditions\_. Conditions are markers for some aspect of the actual state of the thing the object represents. Pods have conditions, and Kubernetes Pod conditions are an important aspect of how controllers (and people doing troubleshooting) can understand the health of a Pod. A Pod's [p... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/pod-condition.md | main | kubernetes | [
-0.028549417853355408,
0.030229808762669563,
0.08156000077724457,
0.02364223264157772,
0.03525908663868904,
-0.009333346039056778,
0.045011844485998154,
-0.04693180322647095,
0.09096729755401611,
0.06225420907139778,
0.0009970397222787142,
-0.041292134672403336,
0.0025057150050997734,
-0.0... | 0.231396 |
`status.conditions` looks like for a running Pod: ```yaml status: conditions: - type: PodScheduled status: "True" lastProbeTime: null lastTransitionTime: "2026-03-29T08:52:21Z" observedGeneration: 1 - type: PodReadyToStartContainers status: "True" lastProbeTime: null lastTransitionTime: "2026-04-11T06:02:16Z" observedG... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/pod-condition.md | main | kubernetes | [
0.033174484968185425,
0.009020531550049782,
-0.0015046864282339811,
-0.0075482954271137714,
0.016178667545318604,
-0.030431967228651047,
-0.04050423577427864,
-0.019687889143824577,
0.031897179782390594,
0.07713253051042557,
0.019758200272917747,
-0.06617644429206848,
-0.06539749354124069,
... | 0.14412 |
`TerminationByKubelet` : Pod has been terminated by the kubelet, because of either {{}}, the [graceful node shutdown](/docs/concepts/architecture/nodes/#graceful-node-shutdown), or preemption for [system critical pods](/docs/tasks/administer-cluster/guaranteed-scheduling-critical-addon-pods/). In all other disruption s... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/pod-condition.md | main | kubernetes | [
0.023014022037386894,
0.038210246711969376,
0.08550459891557693,
0.0497833788394928,
0.07339348644018173,
-0.030292097479104996,
-0.0001725478214211762,
0.0038619874976575375,
0.06794700026512146,
0.06990709155797958,
0.026380673050880432,
0.02324613928794861,
-0.020781783387064934,
-0.056... | 0.186839 |
subresource. You can use `kubectl patch` with `--subresource=status`, or a [Kubernetes client library](/docs/reference/using-api/client-libraries/) to write code that sets custom Pod conditions for Pod readiness. For a Pod that uses custom conditions, that Pod is evaluated to be ready \*\*only\*\* when both the followi... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/pod-condition.md | main | kubernetes | [
0.011063930578529835,
0.029478950425982475,
0.07168332487344742,
0.014698515646159649,
-0.027400286868214607,
-0.017412621527910233,
-0.026729505509138107,
-0.010492668487131596,
0.022531231865286827,
0.040112804621458054,
-0.031838756054639816,
-0.08024872839450836,
-0.004213238134980202,
... | 0.142305 |
\_Static Pods\_ are managed directly by the kubelet daemon on a specific node, without the {{< glossary\_tooltip text="API server" term\_id="kube-apiserver" >}} observing them. Unlike Pods that are managed by the control plane (for example, a {{< glossary\_tooltip text="Deployment" term\_id="deployment" >}}), the kubel... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/static-pods.md | main | kubernetes | [
-0.026725180447101593,
-0.01944524049758911,
0.06597798317670822,
0.029322095215320587,
-0.06368375569581985,
-0.039976608008146286,
0.036002278327941895,
-0.03189399838447571,
0.08845801651477814,
0.026115266606211662,
0.02696307748556137,
-0.09345760941505432,
0.0039946832694113255,
-0.0... | 0.153865 |
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.043942857533693314,
-0.0017727710073813796,
0.08232781291007996,
0.03651932626962662,
0.03798866271972656,
-0.06996159255504608,
0.029994508251547813,
-0.03507569059729576,
0.10916035622358322,
0.02319258451461792,
-0.00361985107883811,
-0.007466183044016361,
-0.02069041132926941,
-0.04... | 0.226479 |
(as defined by a UID) is never "rescheduled" to a different node; instead, that Pod can be replaced by a new, near-identical Pod. If you make a replacement Pod, it can even have same name (as in `.metadata.name`) that the old Pod had, but the replacement would have a different `.metadata.uid` from the old Pod. Kubernet... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/pod-lifecycle.md | main | kubernetes | [
-0.0757066160440445,
-0.0114739453420043,
0.1392492949962616,
0.03128495067358017,
0.04468230903148651,
-0.038358625024557114,
0.024073226377367973,
-0.08088507503271103,
0.14865055680274963,
0.04235576465725899,
-0.01507736835628748,
0.035978082567453384,
-0.00506803160533309,
-0.04922104... | 0.123794 |
is granted a term to terminate gracefully, which defaults to 30 seconds. You can use the flag `--force` to [terminate a Pod by force](/docs/concepts/workloads/pods/pod-lifecycle/#pod-termination-forced). {{< /note >}} Since Kubernetes 1.27, the kubelet transitions deleted Pods to a terminal phase (`Failed` or `Succeede... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/pod-lifecycle.md | main | kubernetes | [
0.022886455059051514,
0.010812094435095787,
0.09287401288747787,
0.011867629364132881,
0.0036473486106842756,
-0.02086314558982849,
-0.022353798151016235,
-0.07493038475513458,
0.1101088598370552,
0.059218455106019974,
0.0015955714043229818,
0.009850566275417805,
-0.027680469676852226,
-0.... | 0.177228 |
repeatedly. 1. \*\*Backoff reset\*\*: If a container runs successfully for a certain duration (e.g., 10 minutes), Kubernetes resets the backoff delay, treating any new crash as the first one. In practice, a `CrashLoopBackOff` is a condition or event that might be seen as output from the `kubectl` command, while describ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/pod-lifecycle.md | main | kubernetes | [
0.027711518108844757,
-0.004809267353266478,
0.060225676745176315,
0.030301637947559357,
0.010499906726181507,
0.03340227156877518,
0.027912521734833717,
0.016341598704457283,
0.06676582992076874,
0.034302499145269394,
-0.004050486721098423,
0.044635578989982605,
-0.012842055410146713,
-0.... | 0.177714 |
`restartPolicy` is either `OnFailure` or `Always`: \* `Always`: Automatically restarts the container after any termination. \* `OnFailure`: Only restarts the container if it exits with an error (non-zero exit status). \* `Never`: Does not automatically restart the terminated container. ##### Restart behavior comparison... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/pod-lifecycle.md | main | kubernetes | [
0.0003509519447106868,
0.013226584531366825,
-0.007702355273067951,
0.017288725823163986,
0.034809548407793045,
0.0062838830053806305,
-0.024500252678990364,
-0.010556885041296482,
-0.0042586359195411205,
-0.02000880055129528,
0.026249859482049942,
0.0459386482834816,
-0.031848277896642685,
... | 0.059906 |
only applies to restarts that make replacement containers inside the same Pod and running on the same node. After containers in a Pod exit, the kubelet restarts them with an exponential backoff delay (10s, 20s, 40s, …), that is capped at 300 seconds (5 minutes). Once a container has executed for 10 minutes without any ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/pod-lifecycle.md | main | kubernetes | [
0.05358845740556717,
-0.0004602401750162244,
0.06418131291866302,
0.04698145389556885,
-0.01793239451944828,
-0.0038562598638236523,
-0.04590054601430893,
-0.04099533334374428,
0.02395711839199066,
-0.0007702573202550411,
-0.0034393153619021177,
0.01931910030543804,
-0.03470972180366516,
-... | 0.122053 |
registry.k8s.io/busybox:1.27.2 command: ['sh', '-c', 'sleep 60 && exit 0'] restartPolicy: Never # Container restart policy must be specified if rules are specified restartPolicyRules: # Only restart the container if it exits with code 42 - action: Restart exitCodes: operator: In values: [42] ``` Restart rules can be us... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/pod-lifecycle.md | main | kubernetes | [
0.07340577989816666,
-0.0013197228545323014,
0.049458667635917664,
0.06810273230075836,
-0.03753427043557167,
0.04052057862281799,
-0.046143367886543274,
-0.04035179689526558,
0.010879588313400745,
0.031860560178756714,
-0.05662829056382179,
-0.012665384449064732,
-0.041424475610256195,
-0... | 0.106107 |
be reduced to begin at 1s (instead of 10s) and increase exponentially by 2x each restart until a maximum delay of 60s (instead of 300s which is 5 minutes). If you use this feature along with the alpha feature `KubeletCrashLoopBackOffMax` (described below), individual nodes may have different maximum delays. ### Configu... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/pod-lifecycle.md | main | kubernetes | [
0.05814716964960098,
-0.01237812452018261,
0.04322738200426102,
0.003926965408027172,
-0.058110035955905914,
0.018927356228232384,
-0.06384077668190002,
-0.02614021673798561,
0.05228538066148758,
0.006300987675786018,
-0.03339405357837677,
-0.04230426624417305,
-0.03990943357348442,
-0.028... | 0.107706 |
gates are determined by the current state of `status.condition` fields for the Pod. If Kubernetes cannot find such a condition in the `status.conditions` field of a Pod, the status of the condition is defaulted to "`False`". Here is an example: ```yaml kind: Pod ... spec: readinessGates: - conditionType: "www.example.c... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/pod-lifecycle.md | main | kubernetes | [
0.027317101135849953,
0.022616617381572723,
0.013042578473687172,
-0.00574300903826952,
-0.017625439912080765,
-0.0018790451576933265,
-0.002275292295962572,
-0.05538032203912735,
0.06156212463974953,
0.0679052472114563,
-0.008830983191728592,
-0.07627014815807343,
-0.033048421144485474,
-... | 0.127715 |
Kubernetes supports changing the CPU and memory resources allocated to Pods after they are created. (For other infrastructure resources, you would need to use different techniques specific to those resources.) There are two main approaches to resizing CPU and memory: ### In-place Pod resize {#pod-resize-inplace} You ca... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/pod-lifecycle.md | main | kubernetes | [
0.04960991442203522,
0.056998565793037415,
0.022307077422738075,
0.050507258623838425,
-0.056108955293893814,
-0.02398138865828514,
0.006819360423833132,
0.012548599392175674,
0.019054101780056953,
0.066508449614048,
-0.04614560306072235,
0.011602302081882954,
-0.03194018080830574,
-0.0559... | 0.154656 |
the remote system (the container) closes the connection immediately after it opens, this counts as healthy. {{< caution >}} Unlike the other mechanisms, `exec` probe's implementation involves the creation/forking of multiple processes each time when executed. As a result, in case of the clusters having higher pod densi... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/pod-lifecycle.md | main | kubernetes | [
0.0300887618213892,
0.03362373262643814,
-0.003734645899385214,
0.05692124739289284,
0.023058941587805748,
-0.09472337365150452,
-0.021376579999923706,
0.0006153314607217908,
0.08507296442985535,
0.05783451348543167,
-0.004757608287036419,
-0.0672319084405899,
-0.016834447160363197,
-0.019... | 0.214288 |
each required back-end service is available. This helps you avoid directing traffic to Pods that can only respond with error messages. If your container needs to work on loading large data, configuration files, or migrations during startup, you can use a [startup probe](#when-should-you-use-a-startup-probe). However, i... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/pod-lifecycle.md | main | kubernetes | [
0.027492478489875793,
0.00038274889811873436,
0.056378331035375595,
0.004356240388005972,
0.0332319550216198,
-0.05665101855993271,
-0.016637956723570824,
-0.01623411476612091,
0.08049625903367996,
0.02752683497965336,
-0.03161250799894333,
0.03472984954714775,
-0.04291074723005295,
-0.008... | 0.181801 |
be defined in the container image with the `STOPSIGNAL` instruction. If no stop signal is defined in the image, the default signal of the container runtime (SIGTERM for both containerd and CRI-O) would be used to kill the container. ### Defining custom stop signals {{< feature-state feature\_gate\_name="ContainerStopSi... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/pod-lifecycle.md | main | kubernetes | [
0.020345261320471764,
0.03670080378651619,
0.03268257901072502,
-0.023398522287607193,
0.05702323466539383,
-0.029120679944753647,
-0.007594619411975145,
-0.025832252576947212,
-0.0024112954270094633,
0.02067388966679573,
-0.016133775934576988,
-0.04888702929019928,
-0.07477044314146042,
-... | 0.171092 |
connections and need more graceful termination, for example, session draining and completion. Any endpoints that represent the terminating Pods are not immediately removed from EndpointSlices, and a status indicating [terminating state](/docs/concepts/services-networking/endpoint-slices/#conditions) is exposed from the... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/pod-lifecycle.md | main | kubernetes | [
0.021466156467795372,
0.01993281953036785,
0.06931081414222717,
-0.012067263945937157,
-0.040113214403390884,
-0.027314379811286926,
-0.033533960580825806,
-0.012143522500991821,
0.08782687038183212,
0.05123419687151909,
-0.04475216567516327,
0.04994845762848854,
-0.07060620188713074,
-0.0... | 0.207996 |
If the grace period expires before the termination process is complete, the Pod may enter [forced termination](#pod-termination-beyond-grace-period). In this case, all remaining containers in the Pod will be terminated simultaneously with a short grace period. Similarly, if the Pod has a `preStop` hook that exceeds the... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/pod-lifecycle.md | main | kubernetes | [
0.03759240731596947,
0.06571846455335617,
0.09266438335180283,
0.002023174660280347,
-0.010901219211518764,
-0.000493900733999908,
-0.029976870864629745,
-0.029589684680104256,
0.08262865245342255,
0.04732022434473038,
0.03870159387588501,
0.030946828424930573,
-0.0353609062731266,
-0.0449... | 0.131457 |
false. This legacy behavior was the default for a long time, but caused issue for people using Kubernetes, especially in large scale deployments. Although the feature gate allows reverting to this legacy behavior temporarily, the Kubernetes project recommends that you file a bug report if you encounter problems. The `C... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/pod-lifecycle.md | main | kubernetes | [
0.045545466244220734,
-0.009459911845624447,
0.08069564402103424,
0.05119185522198677,
0.05258551985025406,
-0.00824064016342163,
-0.008001240901648998,
-0.039166536182165146,
0.02634020708501339,
0.06306715309619904,
0.05024664103984833,
0.009061671793460846,
-0.02949235402047634,
-0.0073... | 0.081585 |
Kubernetes lets you define \_probes\_ to continuously monitor the health of containers in a Pod. A probe is a diagnostic performed periodically by the {{< glossary\_tooltip text="kubelet" term\_id="kubelet" >}} on a container. To perform a diagnostic, the kubelet either executes code within the container or makes a net... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/probes.md | main | kubernetes | [
0.024211876094341278,
0.004390024114400148,
0.055903054773807526,
0.044793751090765,
0.0076933614909648895,
-0.0244914460927248,
0.01865510083734989,
-0.061818454414606094,
0.09902989864349365,
0.014300859533250332,
-0.05223361402750015,
-0.03660383075475693,
-0.016094040125608444,
-0.0140... | 0.222659 |
## When to use each probe {#when-to-use-each-probe} ### When should you use a startup probe? {#when-should-you-use-a-startup-probe} Startup probes are useful for Pods that have containers that take a long time to come into service. Rather than set a long liveness interval, you can configure a separate configuration for... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/probes.md | main | kubernetes | [
0.008412404917180538,
-0.02891445718705654,
0.020496081560850143,
0.04691613093018532,
0.047050442546606064,
-0.05472496151924133,
-0.022633206099271774,
-0.008565296418964863,
-0.006264569703489542,
0.035480499267578125,
0.012626769952476025,
-0.055498797446489334,
-0.04889091104269028,
0... | 0.100591 |
Pod's IP address on a specified port and path. The diagnostic is considered successful if the response has a status code greater than or equal to 200 and less than 400. For more details, see [HTTP probes](#http-probes). `tcpSocket` : Performs a TCP check against the Pod's IP address on a specified port. The diagnostic ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/probes.md | main | kubernetes | [
0.03307875990867615,
0.02442207746207714,
0.002174937864765525,
0.06170951575040817,
0.03168913349509239,
-0.09872724860906601,
0.016907453536987305,
-0.003086466109380126,
0.09343066066503525,
0.08064480125904083,
0.002891083247959614,
-0.003738790052011609,
-0.0492335744202137,
-0.013125... | 0.214109 |
times in a row, Kubernetes considers that the overall check has failed: the container is \_not\_ ready/healthy/live. Defaults to 3. Minimum value is 1. For the case of a startup or liveness probe, if at least `failureThreshold` probes have failed, Kubernetes treats the container as unhealthy and triggers a restart for ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/probes.md | main | kubernetes | [
0.049453336745500565,
0.027807747945189476,
0.0647510215640068,
0.023798158392310143,
-0.004071307834237814,
-0.03553050383925438,
-0.034472107887268066,
-0.03386658802628517,
0.0716685950756073,
0.03746795281767845,
-0.023335736244916916,
-0.03146282583475113,
-0.018802927806973457,
-0.00... | 0.12664 |
is probably the more common case, you should not use `host`, but rather set the `Host` header in `httpHeaders`. For an HTTP probe, the kubelet sends two request headers in addition to the mandatory `Host` header: - `User-Agent`, which defaults to `kube-probe/{{< skew currentVersion >}}` where `{{< skew currentVersion >... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/probes.md | main | kubernetes | [
0.008512971922755241,
0.06743460148572922,
-0.0031346422620117664,
-0.02437029592692852,
-0.0413835309445858,
-0.054638031870126724,
-0.043300218880176544,
-0.0640106052160263,
0.07054329663515091,
0.044030893594026566,
-0.00043027536594308913,
-0.10594671964645386,
-0.01233415026217699,
-... | 0.027106 |
set `service` to the value `liveness` and make your gRPC Health Checking endpoint respond to this request differently than when you set `service` set to `readiness`. This lets you use the same endpoint for different kinds of container health check rather than listening on two different ports. If you want to specify you... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/probes.md | main | kubernetes | [
0.02098359912633896,
0.024275844916701317,
-0.010092249140143394,
-0.06322870403528214,
-0.03525971993803978,
-0.052404530346393585,
0.05196575075387955,
-0.034910090267658234,
0.0241452194750309,
0.03242193162441254,
-0.023222150281071663,
-0.053961656987667084,
-0.022358715534210205,
0.0... | 0.088435 |
{{< feature-state feature\_gate\_name="GenericWorkload" >}} You can link a `Pod` to a [PodGroup](/docs/concepts/workloads/podgroup-api/) to indicate that the `Pod` belongs to a group of `Pods` scheduled together. This enables the scheduler to apply group-level policies such as gang scheduling rather than treating each ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/scheduling-group.md | main | kubernetes | [
-0.03721161559224129,
-0.019136814400553703,
0.014447344467043877,
0.10201479494571686,
-0.004417199641466141,
-0.030422523617744446,
-0.02825157344341278,
-0.051347460597753525,
-0.024576501920819283,
0.008191162720322609,
-0.057298362255096436,
-0.009703763760626316,
-0.047513071447610855,... | 0.175999 |
This guide is for application owners who want to build highly available applications, and thus need to understand what types of disruptions can happen to Pods. It is also for cluster administrators who want to perform automated cluster actions, like upgrading and autoscaling clusters. ## Voluntary and involuntary disru... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/disruptions.md | main | kubernetes | [
0.0347367525100708,
0.0045921895653009415,
0.08452867716550827,
0.03397563844919205,
0.09077279269695282,
-0.028768867254257202,
0.043068449944257736,
0.042418524622917175,
0.042984120547771454,
0.073126420378685,
0.04036038741469383,
-0.009027146734297276,
0.03399871289730072,
-0.05369273... | 0.238033 |
of a replicated application that are down simultaneously from voluntary disruptions. For example, a quorum-based application would like to ensure that the number of replicas running is never brought below the number needed for a quorum. A web front end might want to ensure that the number of replicas serving load never... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/disruptions.md | main | kubernetes | [
-0.012081630527973175,
-0.022486336529254913,
0.0348811149597168,
-0.0037816816475242376,
-0.0051783546805381775,
-0.0622575618326664,
-0.07030725479125977,
-0.011090482585132122,
0.09729572385549545,
0.04529054835438728,
-0.006736353505402803,
0.02178683876991272,
0.033350855112075806,
-0... | 0.216039 |
administrator first tries to drain `node-1` using the `kubectl drain` command. That tool tries to evict `pod-a` and `pod-x`. This succeeds immediately. Both pods go into the `terminating` state at the same time. This puts the cluster in this state: | node-1 \*draining\* | node-2 | node-3 | |:--------------------:|:----... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/disruptions.md | main | kubernetes | [
-0.0002306175447301939,
0.021815890446305275,
0.0656915232539177,
0.04973527044057846,
0.023747721686959267,
-0.056469161063432693,
-0.007547349669039249,
-0.03536965698003769,
0.042709123343229294,
0.0632142424583435,
0.06420842558145523,
-0.02909778617322445,
0.00273272767663002,
-0.0506... | 0.167487 |
For more information, see [Pod priority preemption](/docs/concepts/scheduling-eviction/pod-priority-preemption/). `DeletionByTaintManager` : Pod is due to be deleted by Taint Manager (which is part of the node lifecycle controller within `kube-controller-manager`) due to a `NoExecute` taint that the Pod does not tolera... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/disruptions.md | main | kubernetes | [
0.01895950920879841,
0.05564858391880989,
0.05725724995136261,
0.019054565578699112,
0.06650759279727936,
-0.02465590462088585,
-0.005029015708714724,
-0.046664122492074966,
0.09961868822574615,
0.06873349845409393,
0.03851694613695145,
0.020518742501735687,
-0.04459940269589424,
-0.020660... | 0.180896 |
This page covers advanced Pod configuration topics including [PriorityClasses](#priorityclasses), [RuntimeClasses](#runtimeclasses), [security context](#security-context) within Pods, and introduces aspects of [scheduling](/docs/concepts/scheduling-eviction/#scheduling). ## PriorityClasses \_PriorityClasses\_ allow you... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/advanced-pod-config.md | main | kubernetes | [
-0.028471186757087708,
0.029623588547110558,
0.09047501534223557,
0.05219363793730736,
-0.023709604516625404,
-0.0304365586489439,
0.008900614455342293,
-0.05089212954044342,
0.03268234431743622,
0.05731352046132088,
-0.047022879123687744,
-0.05200270190834999,
-0.05936800315976143,
0.0195... | 0.085107 |
drop Linux capabilities - \*\*Seccomp Profiles\*\*: Set security computing profiles - \*\*SELinux Options\*\*: Configure SELinux context - \*\*AppArmor\*\*: Configure AppArmor profiles for additional access control - \*\*Windows Options\*\*: Configure Windows-specific security settings {{< caution >}} You can also use ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/advanced-pod-config.md | main | kubernetes | [
0.0800900012254715,
0.061769161373376846,
-0.03849317505955696,
-0.014269986189901829,
0.029327191412448883,
-0.0020306999795138836,
0.03776243329048157,
0.06623823940753937,
-0.049354299902915955,
-0.025043930858373642,
-0.0004701717698480934,
-0.0900585949420929,
0.018758272752165794,
0.... | 0.130725 |
This page explains how to set a Pod's hostname, potential side effects after configuration, and the underlying mechanics. ## Default Pod hostname When a Pod is created, its hostname (as observed from within the Pod) is derived from the Pod's metadata.name value. Both the hostname and its corresponding fully qualified d... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/pod-hostname.md | main | kubernetes | [
0.043311502784490585,
-0.007065237499773502,
0.0476507693529129,
0.005156680941581726,
-0.032753728330135345,
-0.07709100842475891,
-0.004096002317965031,
0.002972664777189493,
0.06002439931035042,
0.04748064652085304,
-0.018201377242803574,
-0.039668530225753784,
-0.0024114360567182302,
-... | 0.107347 |
command: - sleep - "3600" name: busybox ``` {{< note >}} This only affects the hostname within the Pod; it does not affect the Pod's A or AAAA records in the cluster DNS server. {{< /note >}} If `hostnameOverride` is set alongside `hostname` and `subdomain` fields: \* The hostname inside the Pod is overridden to the `h... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/pod-hostname.md | main | kubernetes | [
-0.00679620448499918,
-0.017858512699604034,
0.07382369041442871,
0.05195675045251846,
-0.0690789446234703,
-0.05155816301703453,
-0.06719686090946198,
-0.09996573626995087,
0.06946711242198944,
0.060237858444452286,
-0.04119916632771492,
-0.009313015267252922,
-0.04021169990301132,
-0.048... | 0.132391 |
This page introduces \_Quality of Service (QoS) classes\_ in Kubernetes, and explains how Kubernetes assigns a QoS class to each Pod as a consequence of the resource constraints that you specify for the containers in that Pod. Kubernetes relies on this classification to make decisions about which Pods to evict when the... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/pod-qos.md | main | kubernetes | [
-0.05051825940608978,
0.018579958006739616,
0.059937842190265656,
-0.010212619788944721,
0.025544246658682823,
-0.033607397228479385,
0.10348287969827652,
-0.0827324390411377,
0.08157096058130264,
0.0022292081266641617,
-0.04420900344848633,
-0.011588545516133308,
0.012169559486210346,
0.0... | 0.206674 |
in the Pod has a memory or CPU request or limit, or the Pod has a Pod-level memory or CPU request or limit. ### BestEffort Pods in the `BestEffort` QoS class can use node resources that aren't specifically assigned to Pods in other QoS classes. For example, if you have a node with 16 CPU cores available to the kubelet,... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/pod-qos.md | main | kubernetes | [
0.05534237623214722,
0.028628848493099213,
0.0065667033195495605,
0.012668232433497906,
0.03353581205010414,
-0.009788500145077705,
0.0027609586250036955,
0.0168027151376009,
0.053384505212306976,
0.02551395446062088,
-0.012273927219212055,
0.016796981915831566,
-0.018508778885006905,
-0.0... | 0.22161 |
Pod. \* If a Container exceeds its resource request and the node it runs on faces resource pressure, the Pod it is in becomes a candidate for [eviction](/docs/concepts/scheduling-eviction/node-pressure-eviction/). If this occurs, all Containers in the Pod will be terminated. Kubernetes may create a replacement Pod, usu... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/pod-qos.md | main | kubernetes | [
-0.01381740067154169,
0.06146286055445671,
0.04878344014286995,
0.037456732243299484,
0.015660999342799187,
-0.023710640147328377,
0.003948498517274857,
-0.03114956244826317,
0.06151672452688217,
0.045013535767793655,
-0.004377550445497036,
0.01735556498169899,
-0.030185827985405922,
0.007... | 0.19343 |
This page provides an overview of init containers: specialized containers that run before app containers in a {{< glossary\_tooltip text="Pod" term\_id="pod" >}}. Init containers can contain utilities or setup scripts not present in an app image. You can specify init containers in the Pod specification alongside the `c... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/init-containers.md | main | kubernetes | [
-0.0257529579102993,
0.024515455588698387,
0.0991554781794548,
0.003031012834981084,
0.03674572706222534,
-0.030812598764896393,
0.05289420858025551,
-0.015410257503390312,
0.038635123521089554,
0.01770261861383915,
0.021816972643136978,
-0.020883090794086456,
-0.018155528232455254,
-0.053... | 0.152746 |
an image `FROM` another image just to use a tool like `sed`, `awk`, `python`, or `dig` during setup. \* The application image builder and deployer roles can work independently without the need to jointly build a single app image. \* Init containers can run with a different view of the filesystem than app containers in ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/init-containers.md | main | kubernetes | [
-0.11254831403493881,
0.05343703553080559,
0.07111099362373352,
0.0029690354131162167,
0.049938514828681946,
-0.0943964421749115,
0.05326360836625099,
-0.01743447780609131,
0.034690771251916885,
0.023274803534150124,
0.06273144483566284,
-0.039787210524082184,
0.05668700486421585,
-0.02840... | 0.063038 |
16s 1 {kubelet 172.17.4.201} spec.initContainers{init-myservice} Normal Pulling pulling image "busybox" 13s 13s 1 {kubelet 172.17.4.201} spec.initContainers{init-myservice} Normal Pulled Successfully pulled image "busybox" 13s 13s 1 {kubelet 172.17.4.201} spec.initContainers{init-myservice} Normal Created Created conta... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/init-containers.md | main | kubernetes | [
0.04142926633358002,
0.016445687040686607,
0.03843763843178749,
-0.02727345936000347,
0.028533650562167168,
-0.08276262134313583,
0.015427278354763985,
-0.024392632767558098,
0.045748576521873474,
0.04430273547768593,
0.05651849880814552,
-0.0682014524936676,
-0.03037002868950367,
-0.00486... | 0.119489 |
if teams deploy their application as a Job, because `activeDeadlineSeconds` has an effect even after initContainer finished. The Pod which is already running correctly would be killed by `activeDeadlineSeconds` if you set. The name of each app and init container in a Pod must be unique; a validation error is thrown for... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/init-containers.md | main | kubernetes | [
-0.0450945645570755,
0.032288528978824615,
-0.02028920128941536,
0.006974483374506235,
0.023056596517562866,
-0.06998085230588913,
0.021702367812395096,
-0.025727152824401855,
0.0253963153809309,
0.034545619040727615,
0.010361202992498875,
0.02900414727628231,
0.014627124182879925,
0.01909... | 0.212344 |
{{< feature-state state="stable" for\_k8s\_version="v1.25" >}} This page provides an overview of ephemeral containers: a special type of container that runs temporarily in an existing {{< glossary\_tooltip term\_id="pod" >}} to accomplish user-initiated actions such as troubleshooting. You use ephemeral containers to i... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/ephemeral-containers.md | main | kubernetes | [
-0.04065050557255745,
0.028419844806194305,
0.12896226346492767,
-0.000023684866391704418,
0.0006271390011534095,
0.00188967096619308,
0.048808373510837555,
-0.025280075147747993,
0.03535927087068558,
0.035939693450927734,
0.013428429141640663,
-0.06753048300743103,
-0.026658646762371063,
... | 0.085297 |
\_Pods\_ are the smallest deployable units of computing that you can create and manage in Kubernetes. A \_Pod\_ (as in a pod of whales or pea pod) is a group of one or more {{< glossary\_tooltip text="containers" term\_id="container" >}}, with shared storage and network resources, and a specification for how to run the... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/_index.md | main | kubernetes | [
0.01725844293832779,
-0.010631612502038479,
0.06035918742418289,
0.007600277662277222,
0.005533927120268345,
-0.04828968644142151,
0.021883489564061165,
-0.010149500332772732,
0.10072126239538193,
0.05081338435411453,
0.014572559855878353,
-0.04307670518755913,
-0.013371780514717102,
-0.05... | 0.219858 |
created and managed as a group by a workload resource and its {{< glossary\_tooltip text="controller" term\_id="controller" >}}. See [Pods and controllers](#pods-and-controllers) for more information on how Kubernetes uses workload resources, and their controllers, to implement application scaling and auto-healing. Pod... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/_index.md | main | kubernetes | [
-0.03521762788295746,
-0.05741447955369949,
0.045955296605825424,
0.07475052773952484,
-0.011724154464900494,
-0.0299094058573246,
0.05869073048233986,
-0.054497551172971725,
0.11071460694074631,
0.06919912993907928,
0.03134880214929581,
-0.031767357140779495,
0.010925856418907642,
-0.0380... | 0.156347 |
for the entire group at once. ### Pod templates Controllers for {{< glossary\_tooltip text="workload" term\_id="workload" >}} resources create Pods from a \_pod template\_ and manage those Pods on your behalf. PodTemplates are specifications for creating Pods, and are included in workload resources such as [Deployments... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/_index.md | main | kubernetes | [
-0.028130926191806793,
-0.012713376432657242,
0.021737361326813698,
0.029404403641819954,
-0.023589788004755974,
-0.012758701108396053,
0.047369927167892456,
-0.01568160578608513,
0.03693390265107155,
0.025090962648391724,
0.011061413213610649,
-0.0588427372276783,
-0.04497905075550079,
-0... | 0.106359 |
The `resize` subresource allows container resources (`spec.containers[\*].resources`) to be updated. See [Resize Container Resources](/docs/tasks/configure-pod-container/resize-container-resources/) for more details. - \*\*Ephemeral Containers:\*\* The `ephemeralContainers` subresource allows {{< glossary\_tooltip text... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/_index.md | main | kubernetes | [
-0.039212193340063095,
0.02834251895546913,
0.03733914718031883,
0.034702517092227936,
-0.025847837328910828,
-0.021034283563494682,
0.04829101637005806,
0.0035549202002584934,
0.009436401538550854,
0.042742591351270676,
-0.027258770540356636,
-0.03466557338833809,
-0.043221134692430496,
-... | 0.11848 |
Pod shares the network namespace, including the IP address and network ports. Inside a Pod (and \*\*only\*\* then), the containers that belong to the Pod can communicate with one another using `localhost`. When containers in a Pod communicate with entities \*outside the Pod\*, they must coordinate how they use the shar... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/_index.md | main | kubernetes | [
0.07048903405666351,
-0.02307278849184513,
0.03009599819779396,
-0.0053303916938602924,
-0.0005690670805051923,
-0.022152863442897797,
0.004950735718011856,
-0.013522113673388958,
0.07657254487276077,
0.007855040952563286,
-0.026932016015052795,
0.008203696459531784,
0.003929938655346632,
... | 0.20613 |
>}} observing them. Whereas most Pods are managed by the control plane (for example, a {{< glossary\_tooltip text="Deployment" term\_id="deployment" >}}), for static Pods, the kubelet directly supervises each static Pod (and restarts it if it fails). Static Pods are always bound to one {{< glossary\_tooltip term\_id="k... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/_index.md | main | kubernetes | [
0.01653628796339035,
-0.048296306282281876,
0.05775769054889679,
0.04469986632466316,
-0.015195570886135101,
-0.02677920274436474,
0.02685382030904293,
-0.018402228131890297,
0.09909503161907196,
0.049830112606287,
0.0059107886627316475,
-0.05265113711357117,
-0.01318841241300106,
-0.04947... | 0.253558 |
API. The {{< api-reference page="core/pod-v1" >}} object definition describes the object in detail. \* [The Distributed System Toolkit: Patterns for Composite Containers](/blog/2015/06/the-distributed-system-toolkit-patterns/) explains common layouts for Pods with more than one container. \* Read about [Pod topology sp... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/pods/_index.md | main | kubernetes | [
-0.022044412791728973,
0.02208913490176201,
0.030611630529165268,
0.030876921489834785,
0.053971439599990845,
-0.029751036316156387,
-0.03084353543817997,
0.0007371109677478671,
0.0048734275624156,
0.017716120928525925,
-0.05201235041022301,
0.026544267311692238,
-0.017872890457510948,
-0.... | 0.270308 |
In Kubernetes, a \_HorizontalPodAutoscaler\_ automatically updates a workload resource (such as a {{< glossary\_tooltip text="Deployment" term\_id="deployment" >}} or {{< glossary\_tooltip text="StatefulSet" term\_id="statefulset" >}}), with the aim of automatically scaling capacity to match demand. Horizontal scaling ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/autoscaling/horizontal-pod-autoscale.md | main | kubernetes | [
-0.021046524867415428,
0.006336533464491367,
0.05203865095973015,
0.007941650226712227,
-0.08087258785963058,
-0.03646422177553177,
-0.00014893956540618092,
-0.004202910233289003,
0.07383473962545395,
0.03039284609258175,
-0.008343575522303581,
0.0009879992576316,
0.0015658256597816944,
-0... | 0.132501 |
with raw values, not utilization values. - For object metrics and external metrics, a single metric is fetched, which describes the object in question. This metric is compared to the target value, to produce a ratio as above. In the `autoscaling/v2` API version, this value can optionally be divided by the number of Pod... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/autoscaling/horizontal-pod-autoscale.md | main | kubernetes | [
-0.00689772330224514,
-0.03273424878716469,
-0.014294621534645557,
0.05376632139086723,
-0.07932968437671661,
-0.03032856620848179,
-0.016144225373864174,
0.04436233639717102,
0.05288349464535713,
-0.019451556727290154,
-0.016128897666931152,
-0.14342451095581055,
-0.026313653215765953,
0.... | 0.157989 |
to ready to be the first if it occurred within a longer, configurable time since it started. This value is configured with the `--horizontal-pod-autoscaler-cpu-initialization-period` command line option, and its default is 5 minutes. The \\( currentMetricValue \over desiredMetricValue \\) base scale ratio is then calcu... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/autoscaling/horizontal-pod-autoscale.md | main | kubernetes | [
0.02549210749566555,
-0.0344843752682209,
-0.029233261942863464,
0.09623938053846359,
-0.005650570150464773,
-0.03423004224896431,
-0.04042926803231239,
0.08131281286478043,
0.03551821783185005,
0.06481161713600159,
0.04623037949204445,
-0.0436808317899704,
-0.03697020560503006,
-0.0074104... | 0.080626 |
these command line options cluster-wide. ### Key behaviors for pod readiness {#pod-readiness-key-behaviors} - If a Pod is `Ready` and remains `Ready`, it can be counted as contributing metrics even within the delay. - If a Pod rapidly toggles between `Ready` and `Unready`, metrics are ignored until it’s considered stab... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/autoscaling/horizontal-pod-autoscale.md | main | kubernetes | [
0.059366483241319656,
-0.06289339065551758,
0.032436057925224304,
0.09037480503320694,
0.0063688973896205425,
-0.03205660358071327,
-0.05655037611722946,
-0.019948530942201614,
0.028288787230849266,
0.06293123215436935,
0.004928399808704853,
-0.055348895490169525,
-0.05269286409020424,
-0.... | 0.166254 |
HorizontalPodAutoscaler API also supports a container metric source where the HPA can track the resource usage of individual containers across a set of Pods, in order to scale the target resource. This lets you configure scaling thresholds for the containers that matter most in a particular Pod. For example, if you hav... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/autoscaling/horizontal-pod-autoscale.md | main | kubernetes | [
0.0002472327323630452,
0.03758887201547623,
-0.01341154519468546,
0.00900217704474926,
-0.020400168374180794,
-0.05586952343583107,
-0.0318647176027298,
0.03132346644997597,
-0.020887551829218864,
-0.032555676996707916,
-0.011528454720973969,
-0.07396116852760315,
-0.043216902762651443,
0.... | 0.085772 |
[API](/docs/reference/external-api/custom-metrics.v1beta2/). It's provided by "adapter" API servers provided by metrics solution vendors. Check with your metrics pipeline to see if there is a Kubernetes metrics adapter available. - For external metrics, this is the `external.metrics.k8s.io` [API](/docs/reference/extern... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/autoscaling/horizontal-pod-autoscale.md | main | kubernetes | [
-0.04987065866589546,
-0.05433614179491997,
0.00485285883769393,
-0.013378001749515533,
-0.0714605525135994,
-0.011322038248181343,
-0.07605927437543869,
0.05944518744945526,
0.10980573296546936,
-0.03729735314846039,
-0.021518699824810028,
-0.07506702840328217,
-0.04036770015954971,
-0.00... | 0.123108 |
desired state and avoid unwanted changes to workload scale. For example, in the following example snippet, a stabilization window is specified for `scaleDown`. ```yaml behavior: scaleDown: stabilizationWindowSeconds: 300 ``` When the metrics indicate that the target should be scaled down the algorithm looks into previo... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/autoscaling/horizontal-pod-autoscale.md | main | kubernetes | [
0.016775039955973625,
0.023198409005999565,
0.00499028991907835,
0.04895288497209549,
-0.04815995320677757,
-0.041142433881759644,
0.002499049063771963,
0.019716354086995125,
0.0011700293980538845,
-0.01614638976752758,
-0.0040504466742277145,
-0.010312894359230995,
-0.010361306369304657,
... | 0.161548 |
Pods: ```yaml behavior: scaleDown: policies: - type: Percent value: 10 periodSeconds: 60 - type: Pods value: 5 periodSeconds: 60 selectPolicy: Min ``` ### Example: disable scale down The `selectPolicy` value of `Disabled` turns off scaling the given direction. So to prevent downscaling the following policy would be use... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/autoscaling/horizontal-pod-autoscale.md | main | kubernetes | [
0.029598219320178032,
0.04017995297908783,
0.06257281452417374,
0.009845969267189503,
-0.08922605216503143,
-0.0226984154433012,
-0.06229796260595322,
0.025036728009581566,
0.05086566135287285,
0.04295189306139946,
-0.004961713682860136,
-0.035357095301151276,
-0.03515992686152458,
-0.0367... | 0.131559 |
ensure you are running the right number of nodes. You can also read more about [\_vertical\_ Pod autoscaling](/docs/concepts/workloads/autoscaling/vertical-pod-autoscale/). For more information on HorizontalPodAutoscaler: - Read a [walkthrough example](/docs/tasks/run-application/horizontal-pod-autoscale-walkthrough/) ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/autoscaling/horizontal-pod-autoscale.md | main | kubernetes | [
0.051650434732437134,
-0.02223462611436844,
0.04607000574469566,
-0.02250550128519535,
-0.10780433565378189,
-0.014148462563753128,
-0.07265226542949677,
0.04660433158278465,
0.0396667942404747,
0.02883533388376236,
-0.026789989322423935,
-0.056274354457855225,
-0.022115610539913177,
-0.02... | 0.067434 |
In Kubernetes, a \_VerticalPodAutoscaler\_ automatically updates a workload management {{< glossary\_tooltip text="resource" term\_id="api-resource" >}} (such as a {{< glossary\_tooltip text="Deployment" term\_id="deployment" >}} or {{< glossary\_tooltip text="StatefulSet" term\_id="statefulset" >}}), with the aim of a... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/autoscaling/vertical-pod-autoscale.md | main | kubernetes | [
-0.05542536824941635,
0.024758324027061462,
0.0793326124548912,
0.02906484343111515,
-0.07736480236053467,
-0.05267370119690895,
0.05007140710949898,
-0.036715127527713776,
0.08310655504465103,
0.030738383531570435,
-0.0281054750084877,
-0.028336884453892708,
-0.012129967100918293,
-0.0241... | 0.115032 |
triggering their recreation with new resource requests (traditional approach) - Update Pod resources in place without eviction, when the cluster supports in-place Pod resource updates The chosen method depends on the configured update mode, cluster capabilities, and the type of resource change needed. In-place updates,... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/autoscaling/vertical-pod-autoscale.md | main | kubernetes | [
-0.005970560014247894,
-0.04171227291226387,
0.05357612669467926,
0.014217001385986805,
0.03646448627114296,
-0.0539461150765419,
0.01461960468441248,
-0.034444574266672134,
0.05864652991294861,
0.07698101550340652,
0.03135737404227257,
0.023124143481254578,
0.01866750232875347,
-0.0579656... | 0.170041 |
strategies. ## Resource policies Resource policies allow you to fine-tune how the VerticalPodAutoscaler generates recommendations and applies updates. You can set boundaries for resource recommendations, specify which resources to manage, and configure different policies for individual containers within a Pod. You defi... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/autoscaling/vertical-pod-autoscale.md | main | kubernetes | [
-0.00604008324444294,
0.04123681038618088,
-0.004216442815959454,
-0.003120180917903781,
-0.006851102691143751,
-0.03171920031309128,
-0.044428762048482895,
0.031707312911748886,
0.0052787065505981445,
0.028934389352798462,
-0.016869405284523964,
0.0009708883007988334,
0.02179253101348877,
... | 0.083674 |
{{< feature-state for\_k8s\_version="v1.23" state="stable" >}} When your Job has finished, it's useful to keep that Job in the API (and not immediately delete the Job) so that you can tell whether the Job succeeded or failed. Kubernetes' TTL-after-finished {{}} provides a TTL (time to live) mechanism to limit the lifet... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/ttlafterfinished.md | main | kubernetes | [
-0.030547553673386574,
0.02330128662288189,
0.07075488567352295,
0.00881022959947586,
-0.020693190395832062,
0.00874380487948656,
-0.03790011256933212,
-0.06236384063959122,
0.07994340360164642,
0.019413968548178673,
-0.03196224197745323,
0.015388159081339836,
-0.03793209418654442,
0.00539... | 0.110384 |
{{< feature-state for\_k8s\_version="v1.21" state="stable" >}} A \_CronJob\_ creates {{< glossary\_tooltip term\_id="job" text="Jobs" >}} on a repeating schedule. CronJob is meant for performing regular scheduled actions such as backups, report generation, and so on. One CronJob object is like one line of a \_crontab\_... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/cron-jobs.md | main | kubernetes | [
-0.14827324450016022,
-0.02018497884273529,
-0.01707279309630394,
0.01588079333305359,
-0.04506261646747589,
-0.011287172324955463,
0.055101849138736725,
-0.05439237505197525,
0.006005927454680204,
-0.006755684036761522,
-0.023312905803322792,
-0.030763961374759674,
0.020427091047167778,
-... | 0.170342 |
\* \* | | @weekly | Run once a week at midnight on Sunday morning | 0 0 \* \* 0 | | @daily (or @midnight) | Run once a day at midnight | 0 0 \* \* \* | | @hourly | Run once an hour at the beginning of the hour | 0 \* \* \* \* | To generate CronJob schedule expressions, you can also use web tools like [crontab.guru](htt... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/cron-jobs.md | main | kubernetes | [
-0.1562274694442749,
0.029150431975722313,
-0.02447040192782879,
0.04477269947528839,
-0.0648433268070221,
0.015136150643229485,
-0.03606727346777916,
-0.035401761531829834,
-0.07944116741418839,
-0.010480571538209915,
-0.05649982765316963,
-0.07887174934148788,
0.006277607288211584,
0.038... | 0.000837 |
the CronJob controller does not start the Jobs to run the tasks) until you unsuspend the CronJob. {{< caution >}} Executions that are suspended during their scheduled time count as missed Jobs. When `.spec.suspend` changes from `true` to `false` on an existing CronJob without a [starting deadline](#starting-deadline), ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/cron-jobs.md | main | kubernetes | [
-0.10399635881185532,
0.011744119226932526,
0.0018497096607461572,
0.06643515080213547,
0.04002100229263306,
0.025648005306720734,
-0.0471733920276165,
-0.012859368696808815,
-0.08818628638982773,
-0.008414961397647858,
-0.00007257991092046723,
-0.018327997997403145,
0.008131899870932102,
... | 0.013707 |
If there are more than 100 missed schedules, then it does not start the Job and logs the error. ``` too many missed start times. Set or decrease .spec.startingDeadlineSeconds or check clock skew ``` This behavior is applicable for catch-up scheduling and does not mean the CronJob will stop running. For example, when us... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/cron-jobs.md | main | kubernetes | [
-0.08584725856781006,
-0.044584669172763824,
-0.05533508211374283,
0.03813573718070984,
0.013788901269435883,
0.0034356594551354647,
-0.016588760539889336,
-0.020741097629070282,
0.04622603952884674,
0.01813783496618271,
0.043735604733228683,
-0.04387614130973816,
0.024917444214224815,
-0.... | 0.025621 |
A \_DaemonSet\_ ensures that all (or some) Nodes run a copy of a Pod. As nodes are added to the cluster, Pods are added to them. As nodes are removed from the cluster, those Pods are garbage collected. Deleting a DaemonSet will clean up the Pods it created. Some typical uses of a DaemonSet are: - running a cluster stor... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/daemonset.md | main | kubernetes | [
-0.0330006368458271,
0.02824706770479679,
0.013907836750149727,
0.027511542662978172,
0.04049254208803177,
-0.038595639169216156,
0.013445096090435982,
-0.012991932220757008,
0.08913913369178772,
0.032226551324129105,
-0.000689104781486094,
0.012195250019431114,
0.01069599948823452,
-0.087... | 0.227909 |
adds the `spec.affinity.nodeAffinity` field of the Pod to match the target host. After the Pod is created, the default scheduler typically takes over and then binds the Pod to the target host by setting the `.spec.nodeName` field. If the new Pod cannot fit on the node, the default scheduler may preempt (evict) some of ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/daemonset.md | main | kubernetes | [
-0.0004736102418974042,
0.0022806550841778517,
0.030843792483210564,
0.05819001793861389,
0.03727862983942032,
-0.036922551691532135,
-0.020473847165703773,
-0.01390128955245018,
-0.004861032124608755,
0.0089576356112957,
-0.011682447977364063,
-0.002374703297391534,
-0.039092157036066055,
... | 0.122603 |
They do not have clients. - \*\*NodeIP and Known Port\*\*: Pods in the DaemonSet can use a `hostPort`, so that the pods are reachable via the node IPs. Clients know the list of node IPs somehow, and know the port by convention. - \*\*DNS\*\*: Create a [headless service](/docs/concepts/services-networking/service/#headl... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/daemonset.md | main | kubernetes | [
-0.035475198179483414,
-0.036023057997226715,
0.03034823387861252,
-0.03264826536178589,
-0.05759384483098984,
-0.0447617843747139,
-0.0006687974091619253,
-0.038549039512872696,
0.060028668493032455,
0.05835878849029541,
-0.014211258850991726,
0.020786551758646965,
0.01309980172663927,
-0... | 0.191684 |
Pods to run correctly on that particular node. For example, [network plugins](/docs/concepts/extend-kubernetes/compute-storage-net/network-plugins/) often include a component that runs as a DaemonSet. The DaemonSet component makes sure that the node where it's running has working cluster networking. ## {{% heading "wha... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/daemonset.md | main | kubernetes | [
0.002776756649836898,
-0.02867501601576805,
0.023288730531930923,
0.05021410062909126,
-0.007434606086462736,
0.005266173742711544,
-0.011292963288724422,
-0.0062147644348442554,
0.03216595947742462,
0.06360616534948349,
-0.0008318859618157148,
0.02514936961233616,
-0.04466448351740837,
-0... | 0.179794 |
A \_Deployment\_ provides declarative updates for {{< glossary\_tooltip text="Pods" term\_id="pod" >}} and {{< glossary\_tooltip term\_id="replica-set" text="ReplicaSets" >}}. You describe a \_desired state\_ in a Deployment, and the Deployment {{< glossary\_tooltip term\_id="controller" >}} changes the actual state to... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/deployment.md | main | kubernetes | [
-0.06276048719882965,
-0.037218790501356125,
0.0883634015917778,
-0.017394982278347015,
-0.03408537805080414,
-0.05041898041963577,
0.06987310945987701,
-0.10028190910816193,
0.06638434529304504,
0.08490025997161865,
0.05518738552927971,
-0.06027211993932724,
0.02244611643254757,
-0.057519... | 0.062707 |
`kubectl get deployments` to check if the Deployment was created. If the Deployment is still being created, the output is similar to the following: ``` NAME READY UP-TO-DATE AVAILABLE AGE nginx-deployment 0/3 0 0 1s ``` When you inspect the Deployments in your cluster, the following fields are displayed: \* `NAME` list... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/deployment.md | main | kubernetes | [
-0.014701560139656067,
0.015564560890197754,
-0.024317637085914612,
0.0030299555510282516,
-0.02260657027363777,
-0.023732777684926987,
-0.06087828800082207,
-0.06681539118289948,
0.08175746351480484,
0.06665243953466415,
0.001440137391909957,
-0.0768941193819046,
0.009884214028716087,
-0.... | 0.144298 |
to the ReplicaSet selector, Pod template labels, and in any existing Pods that the ReplicaSet might have. ## Updating a Deployment {{< note >}} A Deployment's rollout is triggered if and only if the Deployment's Pod template (that is, `.spec.template`) is changed, for example if the labels or container images of the te... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/deployment.md | main | kubernetes | [
0.03546261787414551,
0.04836989566683769,
0.06651099771261215,
-0.0038526388816535473,
-0.013350342400372028,
-0.005036485381424427,
-0.050936561077833176,
-0.04574483633041382,
0.03630445525050163,
0.04942344129085541,
0.012697050347924232,
-0.0184091255068779,
-0.036774035543203354,
-0.0... | 0.063933 |
be between 3 and 5. \* Get details of your Deployment: ```shell kubectl describe deployments ``` The output is similar to this: ``` Name: nginx-deployment Namespace: default CreationTimestamp: Thu, 30 Nov 2017 10:56:25 +0000 Labels: app=nginx Annotations: deployment.kubernetes.io/revision=2 Selector: app=nginx Replicas... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/deployment.md | main | kubernetes | [
0.01079177763313055,
0.027903271839022636,
0.03294099122285843,
-0.03567548468708992,
-0.02694237418472767,
-0.024474309757351875,
-0.07065124809741974,
-0.014679765328764915,
0.07304441928863525,
0.0513041652739048,
-0.02338959462940693,
-0.11164301633834839,
-0.020456189289689064,
-0.050... | 0.092901 |
It does not wait for the 5 replicas of `nginx:1.14.2` to be created before changing course. ### Label selector updates It is generally discouraged to make label selector updates and it is suggested to plan your selectors up front. A Deployment's label selector is \*\*immutable\*\* after creation; it cannot be updated v... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/deployment.md | main | kubernetes | [
-0.05814023315906525,
0.042627543210983276,
0.1133197620511055,
-0.04175194725394249,
0.028185652568936348,
0.004761401563882828,
-0.013827352784574032,
-0.10565170645713806,
0.0398106575012207,
0.04880497604608536,
0.026768216863274574,
-0.03295231983065605,
-0.02409251220524311,
-0.02913... | 0.05338 |
the number of new replicas (from `nginx-deployment-3066724191`) is 1. ```shell kubectl get rs ``` The output is similar to this: ``` NAME DESIRED CURRENT READY AGE nginx-deployment-1564180365 3 3 3 25s nginx-deployment-2035384211 0 0 0 36s nginx-deployment-3066724191 1 1 0 6s ``` \* Looking at the Pods created, you see... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/deployment.md | main | kubernetes | [
-0.013591025024652481,
-0.03395388647913933,
0.017597878351807594,
-0.0021268241107463837,
0.0035399680491536856,
-0.06187530606985092,
-0.022318745031952858,
-0.05447341874241829,
0.08457743376493454,
0.019626734778285027,
0.041508227586746216,
-0.048476606607437134,
0.004049938637763262,
... | 0.118798 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.