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 |
|---|---|---|---|---|---|
nginx: Image: nginx:1.16.1 Port: 80/TCP QoS Tier: cpu: BestEffort memory: BestEffort Environment Variables: No volumes. ``` ### Rolling Back to a Previous Revision Follow the steps given below to rollback the Deployment from the current version to the previous version, which is version 2. 1. Now you've decided to undo ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/deployment.md | main | kubernetes | [
0.00699254497885704,
0.0993206575512886,
0.059075552970170975,
-0.011972984299063683,
-0.05034551024436951,
-0.009157453663647175,
-0.06430649012327194,
-0.056504521518945694,
0.057562146335840225,
0.045884501188993454,
0.002120367716997862,
0.05232556164264679,
-0.02187192626297474,
-0.00... | -0.042975 |
risk. This is called \*proportional scaling\*. For example, you are running a Deployment with 10 replicas, [maxSurge](#max-surge)=3, and [maxUnavailable](#max-unavailable)=2. \* Ensure that the 10 replicas in your Deployment are running. ```shell kubectl get deploy ``` The output is similar to this: ``` NAME DESIRED CU... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/deployment.md | main | kubernetes | [
-0.008490112610161304,
-0.009384791366755962,
0.038554877042770386,
-0.006286855321377516,
-0.01704336144030094,
-0.059015143662691116,
-0.09974619746208191,
-0.009078077040612698,
0.00878257304430008,
0.0422278568148613,
0.03689432889223099,
-0.029690930619835854,
0.05651140958070755,
-0.... | 0.085696 |
CHANGE-CAUSE 1 ``` \* Get the rollout status to verify that the existing ReplicaSet has not changed: ```shell kubectl get rs ``` The output is similar to this: ``` NAME DESIRED CURRENT READY AGE nginx-2142116321 3 3 3 2m ``` \* You can make as many updates as you wish, for example, update the resources that will be use... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/deployment.md | main | kubernetes | [
-0.01101872231811285,
0.01785142906010151,
-0.001764003885909915,
-0.03805110603570938,
-0.0332239493727684,
-0.04829329997301102,
-0.04409630224108696,
-0.07224573940038681,
0.0555841363966465,
0.0705208107829094,
0.00221890676766634,
-0.05681973323225975,
0.01955590397119522,
-0.07668230... | 0.124029 |
instead affect the `Available` condition). You can check if a Deployment has completed by using `kubectl rollout status`. If the rollout completed successfully, `kubectl rollout status` returns a zero exit code. ```shell kubectl rollout status deployment/nginx-deployment ``` The output is similar to this: ``` Waiting f... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/deployment.md | main | kubernetes | [
0.02628631517291069,
0.010611476376652718,
0.024665547534823418,
-0.02890353463590145,
-0.005917713046073914,
-0.039342887699604034,
-0.0888599157333374,
-0.05940713733434677,
0.0527186319231987,
0.06573418527841568,
0.017044777050614357,
-0.0854983776807785,
-0.0006037675775587559,
-0.018... | 0.037267 |
exceeded, Kubernetes updates the status and the reason for the Progressing condition: ``` Conditions: Type Status Reason ---- ------ ------ Available True MinimumReplicasAvailable Progressing False ProgressDeadlineExceeded ReplicaFailure True FailedCreate ``` You can address an issue of insufficient quota by scaling do... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/deployment.md | main | kubernetes | [
0.013593994081020355,
-0.05493239313364029,
0.03433912992477417,
-0.018437359482049942,
-0.0613371767103672,
-0.026936214417219162,
-0.047979746013879776,
-0.01673431694507599,
0.050222236663103104,
0.13186682760715485,
0.0318310521543026,
-0.07675320655107498,
0.02161916345357895,
-0.0388... | 0.049953 |
the control plane creates new Pods for a Deployment, the `.metadata.name` of the Deployment is part of the basis for naming those Pods. The name of a Deployment must be a valid [DNS subdomain](/docs/concepts/overview/working-with-objects/names#dns-subdomain-names) value, but this can produce unexpected results for the ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/deployment.md | main | kubernetes | [
-0.025266259908676147,
-0.0182010680437088,
0.06660116463899612,
0.002589660231024027,
-0.0545649379491806,
-0.04275104030966759,
-0.013198401778936386,
0.005018592346459627,
0.043093059211969376,
0.04409189894795418,
-0.026215365156531334,
-0.06426967680454254,
-0.07526937872171402,
-0.00... | 0.121218 |
the old Pod is still in a Terminating state). If you need an "at most" guarantee for your Pods, you should consider using a [StatefulSet](/docs/concepts/workloads/controllers/statefulset/). {{< /note >}} #### Rolling Update Deployment The Deployment updates Pods in a rolling update fashion (gradually scale down the old... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/deployment.md | main | kubernetes | [
0.01600799523293972,
-0.023666532710194588,
-0.015758665278553963,
-0.0008973939693532884,
-0.028512107208371162,
-0.07157764583826065,
-0.06366311013698578,
0.03841163590550423,
-0.03083920106291771,
0.08079152554273605,
0.032971903681755066,
0.03746771439909935,
-0.009956701658666134,
-0... | 0.100165 |
a condition with `type: Progressing`, `status: "False"`. and `reason: ProgressDeadlineExceeded` in the status of the resource. The Deployment controller will keep retrying the Deployment. This defaults to 600. If specified, this field needs to be greater than `.spec.minReadySeconds`. ### Min Ready Seconds `.spec.minRea... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/deployment.md | main | kubernetes | [
0.06603807210922241,
-0.029945140704512596,
0.03607255592942238,
0.0732479840517044,
0.011682887561619282,
-0.03480488806962967,
-0.043209776282310486,
-0.028854936361312866,
0.016770992428064346,
0.08102211356163025,
0.022234197705984116,
-0.005059398245066404,
-0.054819852113723755,
-0.0... | 0.126436 |
StatefulSet is the workload API object used to manage stateful applications. {{< glossary\_definition term\_id="statefulset" length="all" >}} ## Using StatefulSets StatefulSets are valuable for applications that require one or more of the following: \* Stable, unique network identifiers. \* Stable, persistent storage. ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/statefulset.md | main | kubernetes | [
-0.006021921522915363,
-0.0356716588139534,
-0.01688295230269432,
0.019070129841566086,
-0.061745189130306244,
-0.015393666923046112,
-0.040966324508190155,
0.0011013125767931342,
0.0014097071252763271,
0.0725516751408577,
-0.045228105038404465,
0.04807261750102043,
0.002696857787668705,
-... | 0.141056 |
a PersistentVolume with the correct StorageClass and sufficient available storage space. ### Minimum ready seconds {{< feature-state for\_k8s\_version="v1.25" state="stable" >}} `.spec.minReadySeconds` is an optional field that specifies the minimum number of seconds for which a newly created Pod should be running and ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/statefulset.md | main | kubernetes | [
0.007563621271401644,
-0.019579678773880005,
0.022878235206007957,
0.06460247933864594,
0.005311621818691492,
-0.0038539133965969086,
-0.03078707866370678,
-0.02162006124854088,
0.05590884014964104,
0.030833924189209938,
0.0023245513439178467,
0.036990370601415634,
-0.024414079263806343,
-... | 0.190182 |
-------------- | ----------------- | --------------------- | ------------------------------- | -------------------------------------------- | ------------ | | cluster.local | default/nginx | default/web | nginx.default.svc.cluster.local | web-{0..N-1}.nginx.default.svc.cluster.local | web-{0..N-1} | | cluster.local | f... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/statefulset.md | main | kubernetes | [
0.0033405933063477278,
-0.006348114460706711,
-0.05005044490098953,
0.011122279800474644,
0.06733474880456924,
-0.005930569488555193,
-0.04256175085902214,
-0.056204408407211304,
0.011236928403377533,
-0.02364523336291313,
0.06323815882205963,
-0.047782763838768005,
-0.06102858483791351,
0... | 0.039459 |
field. #### OrderedReady Pod Management `OrderedReady` pod management is the default for StatefulSets. It implements the behavior described in [Deployment and Scaling Guarantees](#deployment-and-scaling-guarantees). #### Parallel Pod Management `Parallel` pod management tells the StatefulSet controller to launch or ter... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/statefulset.md | main | kubernetes | [
-0.016558034345507622,
-0.04305212199687958,
-0.025398219004273415,
0.00975874811410904,
-0.04110203683376312,
-0.05170769244432449,
-0.06845302879810333,
-0.019048981368541718,
-0.01584445871412754,
0.1030406504869461,
0.04633055254817009,
0.06103294715285301,
-0.009362722747027874,
-0.09... | 0.198553 |
in Beta stage and it is enabled by default. {{< /note >}} ### Forced rollback When using [Rolling Updates](#rolling-updates) with the default [Pod Management Policy](#pod-management-policies) (`OrderedReady`), it's possible to get into a broken state that requires manual intervention to repair. If you update the Pod te... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/statefulset.md | main | kubernetes | [
0.010750528424978256,
0.0004470532003324479,
0.1019306555390358,
0.018331056460738182,
-0.0182005874812603,
0.004194984212517738,
-0.07544346898794174,
-0.08115651458501816,
-0.004370014648884535,
0.08546211570501328,
-0.01289656013250351,
0.12155284732580185,
-0.03344694897532463,
-0.0386... | 0.133498 |
the value to either `Delete` or `Retain`. `Delete` : The PVCs created from the StatefulSet `volumeClaimTemplate` are deleted for each Pod affected by the policy. With the `whenDeleted` policy all PVCs from the `volumeClaimTemplate` are deleted after their Pods have been deleted. With the `whenScaled` policy, only PVCs ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/statefulset.md | main | kubernetes | [
-0.0653388574719429,
-0.004910527728497982,
0.04460317641496658,
0.022889768704771996,
0.062305767089128494,
0.07087746262550354,
0.047388408333063126,
-0.044890280812978745,
0.06196685507893562,
0.05189863219857216,
0.049485333263874054,
0.027973709627985954,
0.02653343789279461,
-0.01327... | 0.12207 |
similar API for horizontal scaling) is managing scaling for a Statefulset, don't set `.spec.replicas`. Instead, allow the Kubernetes {{}} to manage the `.spec.replicas` field automatically. ## {{% heading "whatsnext" %}} \* Learn about [Pods](/docs/concepts/workloads/pods). \* Find out how to use StatefulSets \* Follow... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/statefulset.md | main | kubernetes | [
0.019421366974711418,
0.03127868101000786,
0.005351583007723093,
0.041110292077064514,
-0.09352212399244308,
-0.03440432995557785,
-0.07732247561216354,
0.0146726593375206,
-0.011946498416364193,
0.06317714601755142,
-0.044027164578437805,
-0.055776454508304596,
0.03640415146946907,
-0.036... | 0.143001 |
A ReplicaSet's purpose is to maintain a stable set of replica Pods running at any given time. As such, it is often used to guarantee the availability of a specified number of identical Pods. ## How a ReplicaSet works A ReplicaSet is defined with fields, including a selector that specifies how to identify Pods it can ac... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/replicaset.md | main | kubernetes | [
-0.020438574254512787,
-0.00177835114300251,
0.026208890601992607,
0.0011802701046690345,
0.02982032671570778,
-0.0033121241722255945,
0.029650337994098663,
-0.0437772199511528,
0.11775081604719162,
0.023077024146914482,
-0.005686653312295675,
-0.007580601144582033,
0.024579793214797974,
-... | 0.210414 |
the Pods running: ```shell kubectl get pods frontend-gbgfx -o yaml ``` The output will look similar to this, with the frontend ReplicaSet's info set in the metadata's ownerReferences field: ```yaml apiVersion: v1 kind: Pod metadata: creationTimestamp: "2024-02-28T22:30:44Z" generateName: frontend- labels: tier: fronten... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/replicaset.md | main | kubernetes | [
0.021828962489962578,
0.004231722559779882,
0.043960485607385635,
-0.008131253533065319,
0.024828998371958733,
0.0011057958472520113,
-0.02183784916996956,
-0.03546230494976044,
0.08628660440444946,
0.036069244146347046,
0.03853403776884079,
-0.0814724862575531,
-0.014047833159565926,
-0.0... | 0.082158 |
is `Always`, which is the default. ### Pod Selector The `.spec.selector` field is a [label selector](/docs/concepts/overview/working-with-objects/labels/). As discussed [earlier](#how-a-replicaset-works) these are the labels used to identify potential Pods to acquire. In our `frontend.yaml` example, the selector was: `... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/replicaset.md | main | kubernetes | [
-0.02048579975962639,
0.014567411504685879,
0.01461494155228138,
0.025716464966535568,
0.04554247856140137,
-0.023017054423689842,
-0.00017506552103441209,
-0.030703507363796234,
0.060690876096487045,
-0.016641095280647278,
0.0062631880864501,
-0.057744305580854416,
-0.016102638095617294,
... | 0.138743 |
more replicas come before pods on nodes with fewer replicas. 1. If the pods' creation times differ, the pod that was created more recently comes before the older pod (the creation times are bucketed on an integer log scale). If all of the above match, then selection is random. ### Pod deletion cost {{< feature-state fo... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/replicaset.md | main | kubernetes | [
-0.0006049923831596971,
0.01734665222465992,
0.08261767774820328,
0.023625634610652924,
0.0922279879450798,
0.007499142549932003,
0.07501841336488724,
-0.035308126360177994,
0.15765073895454407,
0.05375995486974716,
0.02155448868870735,
-0.02380187436938286,
-0.00023244571639224887,
-0.036... | 0.139872 |
requires only a single Pod. Think of it similarly to a process supervisor, only it supervises multiple Pods across multiple nodes instead of individual processes on a single node. A ReplicaSet delegates local container restarts to some agent on the node such as Kubelet. ### Job Use a [`Job`](/docs/concepts/workloads/co... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/replicaset.md | main | kubernetes | [
-0.03634198009967804,
-0.03990801051259041,
0.005726237315684557,
0.0003170934214722365,
0.028715146705508232,
0.010407442227005959,
-0.027401152998209,
-0.0291921254247427,
0.06648941338062286,
0.05240171402692795,
-0.03590918332338333,
0.026120690628886223,
-0.019029775634407997,
-0.0291... | 0.246395 |
A Job creates one or more Pods and will continue to retry execution of the Pods until a specified number of them successfully terminate. As pods successfully complete, the Job tracks the successful completions. When a specified number of successful completions is reached, the task (ie, Job) is complete. Deleting a Job ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/job.md | main | kubernetes | [
-0.04721604287624359,
-0.023575467988848686,
0.011756082065403461,
0.06397971510887146,
0.0030678610783070326,
-0.04076340049505234,
-0.04546281322836876,
-0.05230122059583664,
0.021000783890485764,
0.04583517089486122,
-0.010986591689288616,
0.03892342001199722,
-0.013258432038128376,
-0.... | 0.196307 |
Writing a Job spec As with all other Kubernetes config, a Job needs `apiVersion`, `kind`, and `metadata` fields. When the control plane creates new Pods for a Job, the `.metadata.name` of the Job is part of the basis for naming those Pods. The name of a Job must be a valid [DNS subdomain](/docs/concepts/overview/workin... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/job.md | main | kubernetes | [
-0.06502047181129456,
-0.012073139660060406,
0.023211942985653877,
-0.01614469662308693,
-0.08843913674354553,
-0.06255214661359787,
-0.02128208614885807,
-0.044451404362916946,
0.02756296657025814,
0.00028693670174106956,
-0.08206561952829361,
-0.05679332837462425,
-0.05029766634106636,
0... | 0.112498 |
(`.spec.parallelism`) can be set to any non-negative value. If it is unspecified, it defaults to 1. If it is specified as 0, then the Job is effectively paused until it is increased. Actual parallelism (number of pods running at any instant) may be more or less than requested parallelism, for a variety of reasons: - Fo... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/job.md | main | kubernetes | [
-0.07413549721240997,
-0.059612881392240524,
-0.01408139057457447,
0.029257992282509804,
-0.016509532928466797,
-0.034854453057050705,
-0.02424883469939232,
-0.055185701698064804,
0.051108334213495255,
0.082151859998703,
0.07509064674377441,
-0.035287145525217056,
-0.038059432059526443,
-0... | 0.108269 |
the following conditions: - `.spec.parallelism` is greater than 1 - `.spec.completionMode` is `Indexed` - `.spec.parallelism` equals `.spec.completions` - `.spec.template.spec.schedulingGroup` is not set Jobs that do not match these criteria continue to schedule Pods independently, with no `Workload` or `PodGroup` crea... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/job.md | main | kubernetes | [
-0.026641108095645905,
-0.022050924599170685,
0.015155103988945484,
0.09328598529100418,
-0.0018327530706301332,
-0.04228628799319267,
-0.07678256183862686,
-0.09216472506523132,
0.0007245106971822679,
0.010801947675645351,
-0.024067318066954613,
-0.032050952315330505,
-0.06298854947090149,
... | 0.117129 |
failure is counted towards the `.spec.backoffLimit` limit, see [pod backoff failure policy](#pod-backoff-failure-policy). However, you can customize handling of pod failures by setting the Job's [pod failure policy](#pod-failure-policy). Additionally, you can choose to count the pod failures independently for each inde... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/job.md | main | kubernetes | [
0.02081216126680374,
-0.06001468747854233,
0.021539997309446335,
0.059985917061567307,
0.006817595101892948,
-0.0459626242518425,
-0.02704291045665741,
-0.01168826874345541,
-0.010371760465204716,
0.019444113597273827,
-0.005434607155621052,
-0.0022911366540938616,
-0.0036858380772173405,
... | 0.111961 |
if at least one of those indexes did fail, the Job controller marks the overall Job as failed, by setting the Failed condition in the status. The Job gets marked as failed even if some, potentially nearly all, of the indexes were processed successfully. You can additionally limit the maximal number of indexes marked fa... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/job.md | main | kubernetes | [
-0.009134906344115734,
-0.013218925334513187,
0.05135020986199379,
0.06675700843334198,
0.014452840201556683,
-0.04176371544599533,
-0.04791225120425224,
-0.02315525710582733,
-0.007749985437840223,
0.016307085752487183,
-0.018456365913152695,
0.029591962695121765,
-0.003891973290592432,
-... | 0.112444 |
exit code. The following are the rules for the `main` container specifically: - an exit code of 0 means that the container succeeded - an exit code of 42 means that the \*\*entire Job\*\* failed - any other exit code represents that the container failed, and hence the entire Pod. The Pod will be re-created if the total... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/job.md | main | kubernetes | [
0.030948467552661896,
0.02506774291396141,
0.07719679921865463,
0.016713036224246025,
-0.013845627196133137,
0.009211595170199871,
-0.047665685415267944,
-0.011039928533136845,
0.035374969244003296,
-0.004422811791300774,
-0.005440081935375929,
-0.0021034800447523594,
-0.0069723608903586864,... | 0.142507 |
condition. For more details, see [Job termination and cleanup](#job-termination-and-cleanup). ## Success policy {#success-policy} When creating an Indexed Job, you can define when a Job can be declared as succeeded using a `.spec.successPolicy`, based on the pods that succeeded. By default, a Job succeeds when the numb... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/job.md | main | kubernetes | [
-0.09558126330375671,
0.023226242512464523,
-0.004851036239415407,
0.007497887592762709,
0.005102122668176889,
-0.047612447291612625,
-0.009526857174932957,
-0.06277260929346085,
-0.018056416884064674,
0.04703689366579056,
0.015737289562821388,
0.05965716019272804,
0.02861994132399559,
-0.... | 0.174871 |
are deleted too. By default, a Job will run uninterrupted unless a Pod fails (`restartPolicy=Never`) or a Container exits in error (`restartPolicy=OnFailure`), at which point the Job defers to the `.spec.backoffLimit` described above. Once `.spec.backoffLimit` has been reached the Job will be marked as failed and any r... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/job.md | main | kubernetes | [
-0.025578297674655914,
-0.03246914967894554,
-0.005592389032244682,
0.0818869099020958,
0.015257148072123528,
-0.0590415820479393,
-0.04084309935569763,
-0.036587975919246674,
-0.018613889813423157,
0.04298514500260353,
0.00395100237801671,
0.03737049549818039,
-0.04324730113148689,
-0.061... | 0.122098 |
The Job controller adds the `FailureTarget` condition or the `SuccessCriteriaMet` condition to the Job to trigger Pod termination after a Job meets either the success or failure criteria. Factors like `terminationGracePeriodSeconds` might increase the amount of time from the moment that the Job controller adds the `Fai... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/job.md | main | kubernetes | [
0.0038450888823717833,
-0.019680429250001907,
0.0034896256402134895,
0.032806169241666794,
0.04557747393846512,
0.004838033579289913,
-0.016660068184137344,
0.0157089252024889,
0.05855391547083855,
0.060086145997047424,
0.01872817985713482,
-0.035229116678237915,
0.015255286358296871,
-0.0... | 0.13369 |
{{< /note >}} ## Job patterns The Job object can be used to process a set of independent but related \*work items\*. These might be emails to be sent, frames to be rendered, files to be transcoded, ranges of keys in a NoSQL database to scan, and so on. In a complex system, there may be multiple different sets of work i... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/job.md | main | kubernetes | [
-0.1261509358882904,
0.03591541945934296,
-0.04711766541004181,
0.023884031921625137,
-0.027338413521647453,
-0.07627182453870773,
-0.0016205607680603862,
-0.014675959013402462,
0.034685153514146805,
0.03385557234287262,
-0.06177157908678055,
0.028360139578580856,
0.02060980536043644,
-0.0... | 0.205678 |
Pods to satisfy the Job's requirements and will continue to do so until the Job is complete. However, you may want to temporarily suspend a Job's execution and resume it later, or start Jobs in suspended state and have a custom controller decide later when to start them. To suspend a Job, you can update the `.spec.susp... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/job.md | main | kubernetes | [
-0.05208851024508476,
-0.029484154656529427,
0.05469109117984772,
0.06897833198308945,
-0.004085465334355831,
0.003234627889469266,
-0.021602129563689232,
-0.0821443423628807,
0.04369133338332176,
0.05676999315619469,
0.002538393484428525,
0.051638856530189514,
-0.04519243538379669,
-0.015... | 0.151494 |
mix of both. The [suspend](#suspending-a-job) field is the first step towards achieving those semantics. Suspend allows a custom queue controller to decide when a job should start; However, once a job is unsuspended, a custom queue controller has no influence on where the pods of a job will actually land. This feature ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/job.md | main | kubernetes | [
-0.033363644033670425,
0.007164360024034977,
0.03491383418440819,
0.0773354172706604,
0.015751132741570473,
0.02031814493238926,
-0.001240583136677742,
-0.08789563179016113,
0.05417046695947647,
0.06859731674194336,
0.00967305339872837,
0.06660287082195282,
-0.03344709798693657,
-0.0581867... | 0.198988 |
... spec: selector: matchLabels: batch.kubernetes.io/controller-uid: a8f3d00d-c6d2-11e5-9f87-42010af00002 ... ``` Then you create a new Job with name `new` and you explicitly specify the same selector. Since the existing Pods have label `batch.kubernetes.io/controller-uid=a8f3d00d-c6d2-11e5-9f87-42010af00002`, they are... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/job.md | main | kubernetes | [
-0.04786744341254234,
-0.049804408103227615,
-0.015446808189153671,
-0.006643716711550951,
-0.03417667746543884,
0.014729917049407959,
0.030520357191562653,
-0.047178350389003754,
0.031425006687641144,
0.044530048966407776,
0.006863696034997702,
-0.11904484033584595,
-0.06710021197795868,
... | 0.117961 |
```shell kubectl get jobs/myjob -o yaml ``` ```yaml apiVersion: batch/v1 kind: Job # .metadata and .spec omitted status: terminating: 3 # three Pods are terminating and have not yet reached the Failed phase ``` ### Delegation of managing a Job object to external controller {{< feature-state feature\_gate\_name="JobMana... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/job.md | main | kubernetes | [
-0.05161989480257034,
0.009436825290322304,
0.004634297452867031,
0.024724578484892845,
-0.007884826511144638,
-0.03796199709177017,
-0.027484271675348282,
-0.018045609816908836,
0.01944766752421856,
0.04270277917385101,
-0.008512696251273155,
-0.044945742934942245,
-0.024170324206352234,
... | 0.150926 |
a series of Jobs that will run based on a schedule, similar to the UNIX tool `cron`. \* Practice how to configure handling of retriable and non-retriable pod failures using `podFailurePolicy`, based on the step-by-step [examples](/docs/tasks/job/pod-failure-policy/). \* Learn about [gang scheduling](/docs/concepts/sche... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/job.md | main | kubernetes | [
-0.07408083230257034,
-0.026077361777424812,
-0.005943445023149252,
0.018977321684360504,
-0.06918638944625854,
-0.06450717151165009,
-0.057416126132011414,
-0.016961783170700073,
-0.053051840513944626,
0.036672234535217285,
-0.015405061654746532,
0.022232091054320335,
-0.031134555116295815,... | 0.202635 |
Kubernetes provides several built-in APIs for declarative management of your {{< glossary\_tooltip text="workloads" term\_id="workload" >}} and the components of those workloads. Ultimately, your applications run as containers inside {{< glossary\_tooltip term\_id="Pod" text="Pods" >}}; however, managing individual Pod... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/_index.md | main | kubernetes | [
-0.025058364495635033,
-0.009233055636286736,
0.08028741180896759,
0.013798514381051064,
-0.055924996733665466,
-0.045588139444589615,
0.061614155769348145,
-0.011117551475763321,
0.09019558876752853,
0.025438647717237473,
-0.039260122925043106,
-0.0457732118666172,
-0.021477922797203064,
... | 0.100066 |
{{< note >}} A [`Deployment`](/docs/concepts/workloads/controllers/deployment/) that configures a [`ReplicaSet`](/docs/concepts/workloads/controllers/replicaset/) is now the recommended way to set up replication. {{< /note >}} A \_ReplicationController\_ ensures that a specified number of pod replicas are running at an... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/replicationcontroller.md | main | kubernetes | [
-0.03037889301776886,
-0.09706129878759384,
-0.06445758044719696,
-0.00903519056737423,
0.009261714294552803,
0.002291112905368209,
-0.032145462930202484,
0.005719681270420551,
0.02187923900783062,
0.09491005539894104,
0.06895775347948074,
0.06870926916599274,
0.03618994355201721,
-0.04923... | 0.131023 |
ReplicationController must be a valid [DNS subdomain](/docs/concepts/overview/working-with-objects/names#dns-subdomain-names) value, but this can produce unexpected results for the Pod hostnames. For best compatibility, the name should follow the more restrictive rules for a [DNS label](/docs/concepts/overview/working-... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/replicationcontroller.md | main | kubernetes | [
-0.042656995356082916,
-0.025092624127864838,
0.023601915687322617,
-0.008394671604037285,
-0.04562579467892647,
-0.028565499931573868,
-0.020015297457575798,
-0.013486020267009735,
0.0116111533716321,
0.036088909953832626,
-0.03571410849690437,
-0.020506620407104492,
-0.03547373414039612,
... | 0.098215 |
ReplicationController object. Once the original is deleted, you can create a new ReplicationController to replace it. As long as the old and new `.spec.selector` are the same, then the new one will adopt the old pods. However, it will not make any effort to make existing pods match a new, different pod template. To upd... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/replicationcontroller.md | main | kubernetes | [
-0.023286743089556694,
-0.06398065388202667,
-0.014328503981232643,
0.027575744315981865,
0.04647374153137207,
0.004499190021306276,
-0.02405169978737831,
-0.05289287120103836,
0.000022706783056491986,
0.06720559298992157,
0.03755006194114685,
0.05842652916908264,
-0.028660977259278297,
-0... | 0.127347 |
be created and destroyed over the lifetime of a service (for instance, to perform an update of pods that run the service). Both services themselves and their clients should remain oblivious to the ReplicationControllers that maintain the pods of the services. ## Writing programs for Replication Pods created by a Replic... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/replicationcontroller.md | main | kubernetes | [
-0.044892314821481705,
-0.04523729905486107,
-0.0459325835108757,
0.018406741321086884,
-0.06659625470638275,
-0.03230834752321243,
-0.005604699719697237,
-0.017358604818582535,
0.020278912037611008,
0.0991266518831253,
-0.014435661025345325,
0.12007994204759598,
0.04487346112728119,
-0.01... | 0.18914 |
such as a kernel upgrade. For this reason, we recommend that you use a ReplicationController even if your application requires only a single pod. Think of it similarly to a process supervisor, only it supervises multiple pods across multiple nodes instead of individual processes on a single node. A ReplicationControlle... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/workloads/controllers/replicationcontroller.md | main | kubernetes | [
-0.04184868931770325,
-0.04547989368438721,
-0.019685173407197,
-0.01981152966618538,
0.039412952959537506,
-0.025982871651649475,
-0.0721091628074646,
0.029812196269631386,
0.010876094922423363,
0.07657098770141602,
0.014001447707414627,
0.09597110748291016,
0.0004039518826175481,
-0.0476... | 0.189583 |
{{< feature-state state="beta" for\_k8s\_version="v1.11" >}} Cloud infrastructure technologies let you run Kubernetes on public, private, and hybrid clouds. Kubernetes believes in automated, API-driven infrastructure without tight coupling between components. {{< glossary\_definition term\_id="cloud-controller-manager"... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/architecture/cloud-controller.md | main | kubernetes | [
-0.05804014205932617,
-0.0009840951533988118,
0.02708897925913334,
0.020361917093396187,
-0.009663745760917664,
0.00197623367421329,
0.026260778307914734,
-0.03501560539007187,
0.05977262556552887,
0.0708349347114563,
0.0190593134611845,
-0.04115000739693642,
0.00155001156963408,
-0.051736... | 0.078652 |
patch - update ### Others {#authorization-miscellaneous} The implementation of the core of the cloud controller manager requires access to create Event objects, and to ensure secure operation, it requires access to create ServiceAccounts. `v1/Event`: - create - patch - update `v1/ServiceAccount`: - create The {{< gloss... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/architecture/cloud-controller.md | main | kubernetes | [
-0.07950537651777267,
-0.04966581240296364,
-0.038091547787189484,
0.04831565171480179,
-0.00014773222210351378,
0.03059546835720539,
0.05205905809998512,
-0.10284882038831711,
-0.0012779483804479241,
0.142672598361969,
0.0623476542532444,
-0.039511874318122864,
0.05601678043603897,
-0.033... | 0.091397 |
This document catalogs the communication paths between the {{< glossary\_tooltip term\_id="kube-apiserver" text="API server" >}} and the Kubernetes {{< glossary\_tooltip text="cluster" term\_id="cluster" length="all" >}}. The intent is to allow users to customize their installation to harden the network configuration s... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/architecture/control-plane-node-communication.md | main | kubernetes | [
-0.01841139607131481,
-0.02141803503036499,
0.010177314281463623,
0.0038242607843130827,
-0.029453974217176437,
0.0029741902835667133,
0.029605943709611893,
-0.06871693581342697,
0.12570907175540924,
0.04462843015789986,
-0.0065863849595189095,
-0.007827524095773697,
0.007114826701581478,
... | 0.188337 |
connections and are therefore neither authenticated nor encrypted. They can be run over a secure HTTPS connection by prefixing `https:` to the node, pod, or service name in the API URL, but they will not validate the certificate provided by the HTTPS endpoint nor provide client credentials. So while the connection will... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/architecture/control-plane-node-communication.md | main | kubernetes | [
0.001109074568375945,
0.013779927045106888,
-0.005993212573230267,
0.012514973990619183,
-0.04731544107198715,
0.049075350165367126,
-0.004952806979417801,
-0.04897548630833626,
0.09311552345752716,
0.033215638250112534,
-0.04675768315792084,
-0.021254679188132286,
0.02326422743499279,
0.0... | 0.146733 |
{{< feature-state feature\_gate\_name="UnknownVersionInteroperabilityProxy" >}} Kubernetes {{< skew currentVersion >}} includes a beta feature that lets an {{< glossary\_tooltip text="API Server" term\_id="kube-apiserver" >}} proxy resource requests to other \_peer\_ API servers. It also lets clients get a holistic vie... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/architecture/mixed-version-proxy.md | main | kubernetes | [
-0.056564103811979294,
0.00044851971324533224,
0.05370527133345604,
0.026780636981129646,
0.03537507727742195,
-0.003844763617962599,
0.022190630435943604,
-0.09824810922145844,
0.026094233617186546,
0.041016899049282074,
-0.026726242154836655,
-0.007541052997112274,
0.010932684876024723,
... | 0.16194 |
API is turned off on the API server) the API server attempts to send the request to a peer API server that can serve the requested API. It does so by identifying API groups / versions / resources that the local server doesn't recognise, and tries to proxy those requests to a peer API server that is capable of handling ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/architecture/mixed-version-proxy.md | main | kubernetes | [
-0.08920188248157501,
0.023111745715141296,
0.05233188346028328,
0.02030666545033455,
0.08536120504140854,
-0.06509546935558319,
-0.06048915162682533,
-0.07419776916503906,
0.0928708091378212,
0.0712394267320633,
0.005249176174402237,
-0.005034474190324545,
0.029538635164499283,
-0.0114424... | 0.137281 |
Kubernetes is designed with self-healing capabilities that help maintain the health and availability of workloads. It automatically replaces failed containers, reschedules workloads when nodes become unavailable, and ensures that the desired state of the system is maintained. ## Self-Healing capabilities {#self-healing... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/architecture/self-healing.md | main | kubernetes | [
-0.05226960405707359,
-0.010357619263231754,
0.07144230604171753,
0.021986784413456917,
0.031637150794267654,
-0.020081615075469017,
0.014779632911086082,
-0.06458016484975815,
0.09235689789056778,
0.055419132113456726,
-0.018616119399666786,
0.025472519919276237,
-0.011411922983825207,
-0... | 0.210134 |
Kubernetes runs your {{< glossary\_tooltip text="workload" term\_id="workload" >}} by placing {{< glossary\_tooltip text="containers" term\_id="container" >}} into Pods to run on \_Nodes\_. A node may be a virtual or physical machine, depending on the cluster. Each node is managed by the {{< glossary\_tooltip text="con... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/architecture/nodes.md | main | kubernetes | [
-0.013943738304078579,
-0.025898538529872894,
0.07058853656053543,
0.037359971553087234,
-0.040192410349845886,
-0.010378417558968067,
0.06625808775424957,
-0.05954780802130699,
0.10885930061340332,
0.013100270181894302,
-0.02106018364429474,
-0.05530537664890289,
-0.02729957550764084,
-0.... | 0.06859 |
specify a single address for each address family. For example, in a single-stack IPv4 cluster, you set this value to be the IPv4 address that the kubelet should use for the node. See [configure IPv4/IPv6 dual stack](/docs/concepts/services-networking/dual-stack/#configure-ipv4-ipv6-dual-stack) for details of running a ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/architecture/nodes.md | main | kubernetes | [
0.023240456357598305,
-0.00023402449733112007,
0.024994151666760445,
-0.023224009200930595,
-0.09491915255784988,
0.054121989756822586,
-0.04004570096731186,
-0.05952509492635727,
0.08989408612251282,
-0.049539513885974884,
-0.024263227358460426,
-0.12899735569953918,
-0.012009179219603539,
... | 0.103188 |
can use `kubectl` to view a Node's status and other details: ```shell kubectl describe node ``` See [Node Status](/docs/reference/node/node-status/) for more details. ## Node heartbeats Heartbeats, sent by Kubernetes nodes, help your cluster determine the availability of each node, and to take action when failures are ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/architecture/nodes.md | main | kubernetes | [
-0.0002040895924437791,
0.026948800310492516,
0.01787574030458927,
0.04727797582745552,
-0.006421615835279226,
0.013855344615876675,
0.008605033159255981,
-0.07058806717395782,
0.11169519275426865,
0.07101019471883774,
-0.008013169281184673,
-0.08083026111125946,
0.0034610829316079617,
-0.... | 0.136889 |
controller assumes that there is some problem with connectivity between the control plane and the nodes, and doesn't perform any evictions. (If there has been an outage and some nodes reappear, the node controller does evict pods from the remaining nodes that are unhealthy or unreachable). The node controller is also r... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/architecture/nodes.md | main | kubernetes | [
0.02371032163500786,
-0.021204913035035133,
-0.00631693983450532,
0.13361987471580505,
0.04410623386502266,
0.004281817935407162,
-0.014061191119253635,
-0.012285228818655014,
0.02209319733083248,
0.06239290162920952,
0.002933020703494549,
-0.04507565125823021,
-0.010620356537401676,
-0.06... | 0.162528 |
In robotics and automation, a \_control loop\_ is a non-terminating loop that regulates the state of a system. Here is one example of a control loop: a thermostat in a room. When you set the temperature, that's telling the thermostat about your \*desired state\*. The actual room temperature is the \*current state\*. Th... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/architecture/controller.md | main | kubernetes | [
-0.057428132742643356,
-0.013815757818520069,
-0.034632276743650436,
0.034859806299209595,
-0.03686007112264633,
-0.012409050948917866,
0.08462106436491013,
-0.0028127890545874834,
0.11666923761367798,
0.05497219040989876,
0.056248702108860016,
-0.03148863837122917,
0.03575822710990906,
-0... | 0.221848 |
that the controller makes some changes to bring about your desired state, and then reports the current state back to your cluster's API server. Other control loops can observe that reported data and take their own actions. In the thermostat example, if the room is very cold then a different controller might also turn o... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/architecture/controller.md | main | kubernetes | [
-0.006960456259548664,
-0.04462273046374321,
0.0002413820766378194,
0.09135433286428452,
0.038682322949171066,
0.03784095123410225,
-0.026145990937948227,
-0.022728314623236656,
0.11804291605949402,
0.10353962332010269,
-0.021884657442569733,
0.016435086727142334,
0.009125137701630592,
-0.... | 0.149262 |
{{}} This allows the clean up of resources like the following: \* [Terminated pods](/docs/concepts/workloads/pods/pod-lifecycle/#pod-garbage-collection) \* [Completed Jobs](/docs/concepts/workloads/controllers/ttlafterfinished/) \* [Objects without owner references](#owners-dependents) \* [Unused containers and contain... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/architecture/garbage-collection.md | main | kubernetes | [
-0.036717671900987625,
0.06310916692018509,
0.009786047972738743,
0.04739833250641823,
0.07714180648326874,
-0.05667479336261749,
0.02929379604756832,
-0.07440386712551117,
0.08086561411619186,
0.008562575094401836,
0.04868780076503754,
0.041474971920251846,
0.022155089303851128,
0.0109523... | 0.1731 |
the controller deletes the owner object. At this point, the object is no longer visible in the Kubernetes API. During foreground cascading deletion, the only dependents that block owner deletion are those that have the `ownerReference.blockOwnerDeletion=true` field and are in the garbage collection controller cache. Th... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/architecture/garbage-collection.md | main | kubernetes | [
0.02438916452229023,
0.0010828281519934535,
0.042333923280239105,
-0.024812014773488045,
0.01549557689577341,
-0.038318973034620285,
0.02316991798579693,
-0.09557372331619263,
0.18770794570446014,
0.058404590934515,
0.009482093155384064,
-0.0028275600634515285,
-0.025584446266293526,
-0.00... | 0.10022 |
have. Disable by setting to less than `0`. \* `MaxContainers`: the maximum number of dead containers the cluster can have. Disable by setting to less than `0`. In addition to these variables, the kubelet garbage collects unidentified and deleted containers, typically starting with the oldest first. `MaxPerPodContainer`... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/architecture/garbage-collection.md | main | kubernetes | [
0.040415022522211075,
0.045107096433639526,
0.05711371451616287,
-0.018667204305529594,
-0.024858130142092705,
-0.017440596595406532,
-0.022412585094571114,
-0.04242834821343422,
0.043771594762802124,
-0.014606977812945843,
-0.000034105392842320725,
-0.04233816638588905,
-0.00234988634474575... | 0.114205 |
Distributed systems often have a need for \_leases\_, which provide a mechanism to lock shared resources and coordinate activity between members of a set. In Kubernetes, the lease concept is represented by [Lease](/docs/reference/kubernetes-api/cluster-resources/lease-v1/) objects in the `coordination.k8s.io` {{< gloss... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/architecture/leases.md | main | kubernetes | [
-0.06804820150136948,
0.010402311570942402,
0.00335845910012722,
0.02936421148478985,
-0.04029064625501633,
0.022433625534176826,
-0.007058152928948402,
-0.08156363666057587,
0.16500245034694672,
0.051532428711652756,
-0.00970927532762289,
-0.025774724781513214,
0.020126134157180786,
-0.05... | 0.25342 |
run a custom {{< glossary\_tooltip term\_id="controller" text="controller" >}} where a primary or leader member performs operations that its peers do not. You define a Lease so that the controller replicas can select or elect a leader, using the Kubernetes API for coordination. If you do use a Lease, it's a good practi... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/architecture/leases.md | main | kubernetes | [
-0.03595777601003647,
-0.037710681557655334,
0.03584833815693855,
-0.06055803224444389,
-0.06149488314986229,
0.037601351737976074,
0.08384066075086594,
-0.03401387482881546,
0.1149960458278656,
0.03785324469208717,
0.01492626965045929,
-0.02952861413359642,
0.08136013895273209,
0.00561278... | 0.008984 |
On Linux, {{< glossary\_tooltip text="control groups" term\_id="cgroup" >}} constrain resources that are allocated to processes. The {{< glossary\_tooltip text="kubelet" term\_id="kubelet" >}} and the underlying container runtime need to interface with cgroups to enforce [resource management for pods and containers](/d... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/architecture/cgroups.md | main | kubernetes | [
-0.06466664373874664,
0.02374882809817791,
-0.03950151801109314,
0.0310876052826643,
-0.03096713498234749,
-0.016012802720069885,
0.03465848043560982,
-0.0005574607639573514,
0.04248364269733429,
-0.05707862973213196,
0.006562747992575169,
-0.09563075751066208,
-0.033969879150390625,
-0.03... | 0.212888 |
example: \* Some third-party monitoring and security agents may depend on the cgroup filesystem. Update these agents to versions that support cgroup v2. \* If you run [cAdvisor](https://github.com/google/cadvisor) as a stand-alone DaemonSet for monitoring pods and containers, update it to v0.43.0 or later. \* If you de... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/architecture/cgroups.md | main | kubernetes | [
-0.04335230588912964,
0.0005780024221166968,
-0.03792238608002663,
-0.05436321720480919,
0.01730106957256794,
-0.06951868534088135,
-0.04432373493909836,
0.030773146077990532,
-0.01015731692314148,
-0.029419951140880585,
0.04616815969347954,
-0.0399693101644516,
-0.036135170608758926,
-0.0... | 0.205099 |
A Kubernetes cluster consists of a control plane plus a set of worker machines, called nodes, that run containerized applications. Every cluster needs at least one worker node in order to run Pods. The worker node(s) host the Pods that are the components of the application workload. The control plane manages the worker... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/architecture/_index.md | main | kubernetes | [
0.025122642517089844,
-0.007437027990818024,
0.034788601100444794,
0.019876092672348022,
-0.024246670305728912,
0.05379544571042061,
-0.03395293653011322,
-0.008921713568270206,
0.04617553949356079,
0.053981389850378036,
-0.07062869518995285,
-0.03408302366733551,
-0.0049590300768613815,
-... | 0.190648 |
Route controller: For setting up routes in the underlying cloud infrastructure - Service controller: For creating, updating and deleting cloud provider load balancers --- ## Node components Node components run on every node, maintaining running pods and providing the Kubernetes runtime environment. ### kubelet {{< glos... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/architecture/_index.md | main | kubernetes | [
-0.027963345870375633,
-0.02631700225174427,
0.044384319335222244,
0.01577635109424591,
-0.09746158123016357,
0.04509080946445465,
0.0031611945014446974,
-0.03231026604771614,
0.0497751384973526,
0.06450144946575165,
-0.05874734744429588,
-0.04548073187470436,
-0.006358445156365633,
-0.081... | 0.076347 |
and managing clusters, each with its own method of component layout and management. ### Customization and extensibility Kubernetes architecture allows for significant customization: - Custom schedulers can be deployed to work alongside the default Kubernetes scheduler or to replace it entirely. - API servers can be ext... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/architecture/_index.md | main | kubernetes | [
-0.006671825423836708,
-0.0020652927923947573,
0.025907646864652634,
0.03428488224744797,
-0.02016209252178669,
0.04450758174061775,
-0.05929416045546532,
-0.0027804644778370857,
0.08307872712612152,
0.08274271339178085,
-0.05494504049420357,
-0.0021362206898629665,
0.02522856928408146,
-0... | 0.218553 |
Operators are software extensions to Kubernetes that make use of [custom resources](/docs/concepts/extend-kubernetes/api-extension/custom-resources/) to manage applications and their components. Operators follow Kubernetes principles, notably the [control loop](/docs/concepts/architecture/controller). ## Motivation The... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/extend-kubernetes/operator.md | main | kubernetes | [
-0.0367877371609211,
0.002748564351350069,
0.03384511172771454,
-0.03466770052909851,
-0.09922408312559128,
-0.04470963031053543,
0.07226652652025223,
-0.005664998199790716,
0.04213622584939003,
0.029313527047634125,
-0.02524937503039837,
-0.011014387011528015,
-0.015222141519188881,
-0.01... | 0.301942 |
and its associated Controller to your cluster. The Controller will normally run outside of the {{< glossary\_tooltip text="control plane" term\_id="control-plane" >}}, much as you would run any containerized application. For example, you can run the controller in your cluster as a Deployment. ## Using an operator {#usi... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/extend-kubernetes/operator.md | main | kubernetes | [
-0.0041199903935194016,
-0.021080611273646355,
-0.02119523100554943,
0.00989100057631731,
-0.11571959406137466,
-0.01978791318833828,
0.08037643134593964,
-0.05644842982292175,
0.05259506776928902,
0.03608972206711769,
-0.02376830019056797,
-0.06859130412340164,
0.013864895328879356,
-0.08... | 0.154871 |
Kubernetes is highly configurable and extensible. As a result, there is rarely a need to fork or submit patches to the Kubernetes project code. This guide describes the options for customizing a Kubernetes cluster. It is aimed at {{< glossary\_tooltip text="cluster operators" term\_id="cluster-operator" >}} who want to... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/extend-kubernetes/_index.md | main | kubernetes | [
-0.04231000691652298,
-0.019541550427675247,
0.07184291630983353,
-0.021746288985013962,
-0.016451213508844376,
0.021137908101081848,
0.06352995336055756,
0.0025887666270136833,
0.01627429760992527,
0.03804417699575424,
-0.02880866639316082,
-0.05611170455813408,
-0.02134678326547146,
-0.0... | 0.157503 |
the webhook call serves as a one-way notification to another system or component. In the Kubernetes ecosystem, even synchronous HTTP callouts are often described as “webhooks”. {{< /note >}} In the webhook model, Kubernetes makes a network request to a remote service. With the alternative \*binary Plugin\* model, Kuber... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/extend-kubernetes/_index.md | main | kubernetes | [
-0.08248578757047653,
0.060056064277887344,
-0.03632434085011482,
-0.0436280332505703,
-0.030529646202921867,
-0.0461651049554348,
0.013878300786018372,
-0.012507380917668343,
0.10813259333372116,
0.009166260249912739,
-0.023883292451500893,
-0.05964279547333717,
0.007207238581031561,
-0.0... | 0.290321 |
about Custom Resources, see the [Custom Resources](/docs/concepts/extend-kubernetes/api-extension/custom-resources/) concept guide. ### API aggregation layer You can use Kubernetes' [API Aggregation Layer](/docs/concepts/extend-kubernetes/api-extension/apiserver-aggregation/) to integrate the Kubernetes API with additi... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/extend-kubernetes/_index.md | main | kubernetes | [
-0.07716517895460129,
-0.013203278183937073,
0.0043213386088609695,
0.04088253527879715,
-0.08257216215133667,
0.00454834196716547,
0.06212063878774643,
0.012465346604585648,
0.06384874880313873,
0.036405421793460846,
-0.013016412034630775,
-0.08649573475122452,
0.00628344900906086,
0.0049... | 0.159738 |
since Kubernetes v1.23 (in favour of CSI). FlexVolume plugins allow users to mount volume types that aren't natively supported by Kubernetes. When you run a Pod that relies on FlexVolume storage, the kubelet calls a binary plugin to mount the volume. The archived [FlexVolume](https://git.k8s.io/design-proposals-archive... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/extend-kubernetes/_index.md | main | kubernetes | [
0.031596120446920395,
-0.025898005813360214,
0.017216714099049568,
-0.011980181559920311,
-0.03244468942284584,
0.01765328273177147,
-0.045437250286340714,
0.07435522973537445,
0.08292773365974426,
0.015846507623791695,
-0.01172788254916668,
-0.01756913959980011,
-0.005261310376226902,
0.0... | 0.123786 |
Kubernetes (version 1.3 through to the latest {{< skew latestVersion >}}, and likely onwards) lets you use [Container Network Interface](https://github.com/containernetworking/cni) (CNI) plugins for cluster networking. You must use a CNI plugin that is compatible with your cluster and that suits your needs. Different p... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/extend-kubernetes/compute-storage-net/network-plugins.md | main | kubernetes | [
0.006694086827337742,
-0.04235384985804558,
0.006176420487463474,
-0.029231121763586998,
-0.022927848622202873,
0.07450796663761139,
-0.05117812380194664,
-0.011131108738481998,
0.005939463619142771,
0.027364790439605713,
-0.02379824034869671,
-0.051810864359140396,
-0.044433146715164185,
... | 0.138923 |
`kubernetes.io/ingress-bandwidth` and `kubernetes.io/egress-bandwidth` annotations to your Pod. For example: ```yaml apiVersion: v1 kind: Pod metadata: annotations: kubernetes.io/ingress-bandwidth: 1M kubernetes.io/egress-bandwidth: 1M ... ``` ## {{% heading "whatsnext" %}} - Learn more about [Cluster Networking](/docs... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/extend-kubernetes/compute-storage-net/network-plugins.md | main | kubernetes | [
0.0386994294822216,
0.025731921195983887,
0.006789598613977432,
0.012102199718356133,
0.03228209167718887,
-0.011901955120265484,
-0.0237946268171072,
0.014396614395081997,
0.006571842357516289,
0.08823961019515991,
-0.029492808505892754,
-0.07083972543478012,
-0.06285989284515381,
-0.0185... | 0.191907 |
{{< feature-state for\_k8s\_version="v1.26" state="stable" >}} Kubernetes provides a device plugin framework that you can use to advertise system hardware resources to the {{< glossary\_tooltip term\_id="kubelet" >}}. Instead of customizing the code for Kubernetes itself, vendors can implement a device plugin that you ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/extend-kubernetes/compute-storage-net/device-plugins.md | main | kubernetes | [
-0.059796836227178574,
-0.004979297053068876,
0.0467061921954155,
-0.02857232838869095,
-0.06381192803382874,
-0.0007109376019798219,
0.0652017891407013,
0.01385598536580801,
0.07913666218519211,
-0.0014686034992337227,
-0.0007018651813268661,
-0.07502854615449905,
-0.03294190391898155,
-0... | 0.181273 |
available in the container rpc Allocate(AllocateRequest) returns (AllocateResponse) {} // GetPreferredAllocation returns a preferred set of devices to allocate // from a list of available ones. The resulting preferred allocation is not // guaranteed to be the allocation ultimately performed by the // devicemanager. It ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/extend-kubernetes/compute-storage-net/device-plugins.md | main | kubernetes | [
0.010418945923447609,
-0.011721148155629635,
-0.004007290117442608,
0.06928545981645584,
0.035577673465013504,
0.038792237639427185,
0.037234045565128326,
0.019138460978865623,
0.003625506069511175,
0.04448710009455681,
0.07372687757015228,
0.050264157354831696,
-0.014734718017280102,
0.06... | 0.074586 |
It is typical that code relying on the device will start failing and Pod may get into Failed phase if `restartPolicy` for the Pod was not `Always` or enter the crash loop otherwise. Before Kubernetes v1.31, the way to know whether or not a Pod is associated with the failed device is to use the [PodResources API](#monit... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/extend-kubernetes/compute-storage-net/device-plugins.md | main | kubernetes | [
0.060573529452085495,
-0.011160312220454216,
0.051923252642154694,
0.04156438261270523,
0.07054867595434189,
-0.016995025798678398,
0.03146688640117645,
-0.007200363092124462,
0.02363528497517109,
0.04968132823705673,
-0.024456188082695007,
-0.020781226456165314,
0.0007860041805543005,
0.0... | 0.168645 |
service to enable discovery of in-use devices, and to provide metadata for these devices: ```gRPC // PodResourcesLister is a service provided by the kubelet that provides information about the // node resources consumed by pods and containers on the node service PodResourcesLister { rpc List(ListPodResourcesRequest) re... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/extend-kubernetes/compute-storage-net/device-plugins.md | main | kubernetes | [
-0.015613330528140068,
-0.0017810044810175896,
-0.026951158419251442,
-0.019795138388872147,
0.02757113054394722,
-0.003617125330492854,
0.042412079870700836,
0.01738053560256958,
0.04255567491054535,
0.041428256779909134,
-0.0121450861915946,
-0.007667893078178167,
-0.022205233573913574,
... | 0.323363 |
If the goal is to evaluate free/unallocated resources it should be used in conjunction with the List() endpoint. The result obtained by `GetAllocatableResources` would remain the same unless the underlying resources exposed to kubelet change. This happens rarely but when it does (for example: hotplug/hotunplug, device ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/extend-kubernetes/compute-storage-net/device-plugins.md | main | kubernetes | [
0.0012317579239606857,
0.03034399077296257,
-0.025126967579126358,
0.02071397379040718,
-0.026899171993136406,
-0.0196708831936121,
0.05848849564790726,
0.014002797193825245,
0.07925280928611755,
-0.010258430615067482,
-0.003059077775105834,
-0.05280893296003342,
-0.03475555405020714,
-0.0... | 0.181612 |
part of the device registration, along with the device IDs and the health of the device. The device manager will then use this information to consult with the Topology Manager and make resource assignment decisions. `TopologyInfo` supports setting a `nodes` field to either `nil` or a list of NUMA nodes. This allows the... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/extend-kubernetes/compute-storage-net/device-plugins.md | main | kubernetes | [
-0.014771719463169575,
-0.033580634742975235,
-0.057257525622844696,
-0.005443404894322157,
0.009568925946950912,
-0.040875259786844254,
0.02194046415388584,
-0.010514896363019943,
-0.06066180020570755,
-0.023209942504763603,
0.033245209604501724,
-0.07620925456285477,
0.030892562121152878,
... | 0.244342 |
This section covers extensions to your cluster that do not come as part as Kubernetes itself. You can use these extensions to enhance the nodes in your cluster, or to provide the network fabric that links Pods together. \* [CSI](/docs/concepts/storage/volumes/#csi) and [FlexVolume](/docs/concepts/storage/volumes/#flexv... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/extend-kubernetes/compute-storage-net/_index.md | main | kubernetes | [
0.020556701347231865,
-0.03563370555639267,
0.018477147445082664,
0.049371618777513504,
0.038748569786548615,
0.04186562821269035,
-0.04148218035697937,
0.04651373252272606,
0.05187375843524933,
0.035693492740392685,
-0.0039555374532938,
0.017834370955824852,
0.0009756616200320423,
0.00333... | 0.213713 |
\*Custom resources\* are extensions of the Kubernetes API. This page discusses when to add a custom resource to your Kubernetes cluster and when to use a standalone service. It describes the two methods for adding custom resources and how to choose between them. ## Custom resources A \*resource\* is an endpoint in the ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/extend-kubernetes/api-extension/custom-resources.md | main | kubernetes | [
-0.05407603085041046,
0.0010941538494080305,
0.01644674688577652,
0.05090390518307686,
-0.004193504806607962,
0.008553591556847095,
0.08099754899740219,
-0.019995758309960365,
0.11887827515602112,
-0.006662933621555567,
-0.00007128187280613929,
-0.017081990838050842,
0.00882760714739561,
-... | 0.290114 |
### Declarative APIs In a Declarative API, typically: - Your API consists of a relatively small number of relatively small objects (resources). - The objects define configuration of applications or infrastructure. - The objects are updated relatively infrequently. - Humans often need to read and write the objects. - Th... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/extend-kubernetes/api-extension/custom-resources.md | main | kubernetes | [
-0.09947974979877472,
0.02087135799229145,
0.015772080048918724,
-0.0010972915915772319,
-0.05190663039684296,
-0.12840338051319122,
-0.06230848655104637,
0.03651278093457222,
0.03397412225604057,
0.046645719558000565,
-0.04317130893468857,
0.04259096086025238,
0.004785244818776846,
-0.001... | 0.160508 |
subordinate API servers that sit behind the primary API server, which acts as a proxy. This arrangement is called [API Aggregation](/docs/concepts/extend-kubernetes/api-extension/apiserver-aggregation/)(AA). To users, the Kubernetes API appears extended. CRDs allow users to create new types of resources without adding ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/extend-kubernetes/api-extension/custom-resources.md | main | kubernetes | [
-0.05383696034550667,
0.005604886915534735,
0.07170671969652176,
0.013012830168008804,
-0.04585043713450432,
-0.017097335308790207,
-0.03197178244590759,
0.0180344320833683,
0.14782439172267914,
0.06013846397399902,
-0.04540475085377693,
0.007993657141923904,
0.04584766924381256,
-0.012092... | 0.124303 |
| No ongoing support once the CRD is created. Any bug fixes are picked up as part of normal Kubernetes Master upgrades. | May need to periodically pickup bug fixes from upstream and rebuild and update the Aggregated API server. | | No need to handle multiple versions of your API; for example, when you control the clien... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/extend-kubernetes/api-extension/custom-resources.md | main | kubernetes | [
-0.06964457035064697,
0.00016438448801636696,
0.09108415246009827,
0.0017641647718846798,
0.018781527876853943,
0.019245995208621025,
-0.12613993883132935,
-0.01365193072706461,
0.06073002517223358,
0.01304374448955059,
-0.004957007709890604,
-0.008498468436300755,
0.04819805920124054,
-0.... | 0.051495 |
| Yes, based on the [OpenAPI v3.0 validation](/docs/tasks/extend-kubernetes/custom-resources/custom-resource-definitions/#validation) schema (GA in 1.16). | Yes | | Instance Name | Does this extension mechanism impose any constraints on the names of objects whose kind/resource is defined this way? | Yes, such an object... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/extend-kubernetes/api-extension/custom-resources.md | main | kubernetes | [
-0.10313864052295685,
0.005299385637044907,
0.0432630255818367,
-0.018240980803966522,
-0.02443360723555088,
-0.06115288659930229,
-0.010447727516293526,
-0.06344503164291382,
0.0848461166024208,
-0.0039298925548791885,
-0.05872683972120285,
-0.07703932374715805,
0.0459384061396122,
0.0609... | 0.124033 |
the new resources (except the cluster-admin role or any role created with wildcard rules). You'll need to explicitly grant access to the new resources. CRDs and Aggregated APIs often come bundled with new role definitions for the types they add. Aggregated API servers may or may not use the same authentication, authori... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/extend-kubernetes/api-extension/custom-resources.md | main | kubernetes | [
-0.02459159679710865,
-0.014927692711353302,
0.018681298941373825,
0.01841977797448635,
-0.048678621649742126,
0.010263609699904919,
-0.017605630680918694,
0.0026792471762746572,
0.08680830895900726,
-0.008884149603545666,
-0.03352442756295204,
-0.03441363945603371,
0.03381693735718727,
0.... | 0.073256 |
The aggregation layer allows Kubernetes to be extended with additional APIs, beyond what is offered by the core Kubernetes APIs. The additional APIs can either be ready-made solutions such as a [metrics server](https://github.com/kubernetes-sigs/metrics-server), or APIs that you develop yourself. The aggregation layer ... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/extend-kubernetes/api-extension/apiserver-aggregation.md | main | kubernetes | [
-0.09013070911169052,
-0.029067162424325943,
0.05285611003637314,
0.04792901873588562,
-0.08498891443014145,
0.02921806275844574,
0.02851097658276558,
-0.014768116176128387,
0.14882799983024597,
-0.013730619102716446,
-0.049723878502845764,
-0.05629068613052368,
0.0072682928293943405,
-0.0... | 0.171218 |
Custom resources are extensions of the Kubernetes API. Kubernetes provides two ways to add custom resources to your cluster: - The [CustomResourceDefinition](/docs/concepts/extend-kubernetes/api-extension/custom-resources/) (CRD) mechanism allows you to declaratively define a new custom API with an API group, kind, and... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/extend-kubernetes/api-extension/_index.md | main | kubernetes | [
-0.030388999730348587,
-0.019548088312149048,
0.021621787920594215,
0.04499087110161781,
-0.04241438955068588,
0.05117351934313774,
-0.004315000958740711,
0.019006261602044106,
0.13593512773513794,
0.056848522275686264,
-0.02135424315929413,
0.00004509371137828566,
0.01859482377767563,
-0.... | 0.210645 |
A container image represents binary data that encapsulates an application and all its software dependencies. Container images are executable software bundles that can run standalone and that make very well-defined assumptions about their runtime environment. You typically create a container image of your application an... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/containers/images.md | main | kubernetes | [
0.015981078147888184,
0.04067542031407356,
0.06427748501300812,
-0.030323583632707596,
0.05247742682695389,
-0.010069926269352436,
0.015883201733231544,
0.0032679985743016005,
0.071073018014431,
0.007801034953445196,
0.024182237684726715,
-0.04837843403220177,
-0.03356719762086868,
-0.0157... | 0.147546 |
image is pulled only if it is not already present locally. `Always` : every time the kubelet launches a container, the kubelet queries the container image registry to resolve the name to an image [digest](https://docs.docker.com/engine/reference/commandline/pull/#pull-an-image-by-digest-immutable-identifier). If the ku... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/containers/images.md | main | kubernetes | [
0.017147043719887733,
0.09301698207855225,
0.07703646272420883,
-0.007867242209613323,
0.0030048652552068233,
-0.06008279323577881,
0.006201489828526974,
-0.012536078691482544,
0.11577897518873215,
-0.02010633610188961,
0.002345521003007889,
-0.038148194551467896,
-0.014215490780770779,
-0... | 0.048842 |
to a `:latest` tag, the `imagePullPolicy` field will \_not\_ change to `Always`. You must manually change the pull policy of any object after its initial creation. {{< /note >}} #### Required image pull If you would like to always force a pull, you can do one of the following: - Set the `imagePullPolicy` of the contain... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/containers/images.md | main | kubernetes | [
0.006198852322995663,
0.013183219358325005,
0.06857867538928986,
0.028531154617667198,
0.017164815217256546,
-0.021709401160478592,
-0.019301077350974083,
-0.02040296234190464,
0.04652795195579529,
0.05018129572272301,
0.03610860928893089,
-0.018918978050351143,
-0.008910197764635086,
0.01... | 0.049789 |
of parallel image pulls, you can set the field `maxParallelImagePulls` in the kubelet configuration. With `maxParallelImagePulls` set to \_n\_, only \_n\_ images can be pulled at the same time, and any image pull beyond \_n\_ will have to wait until at least one ongoing image pull is complete. Limiting the number of pa... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/containers/images.md | main | kubernetes | [
-0.0015175563748925924,
0.03301367163658142,
0.02887669764459133,
-0.05290791764855385,
-0.12097243219614029,
-0.017734743654727936,
-0.06088556349277496,
-0.003567568026483059,
0.04345155507326126,
-0.018121175467967987,
-0.00482444791123271,
-0.1014176458120346,
-0.015577123500406742,
-0... | 0.092754 |
pulls {#kubelet-credential-provider} You can configure the kubelet to invoke a plugin binary to dynamically fetch registry credentials for a container image. This is the most robust and versatile way to fetch credentials for private registries, but also requires kubelet-level configuration to enable. This technique can... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/containers/images.md | main | kubernetes | [
-0.09915444254875183,
0.016040105372667313,
0.022240640595555305,
-0.015595496632158756,
-0.10495065897703171,
-0.0018626017263159156,
0.07134902477264404,
0.012637520208954811,
0.05865887552499771,
0.005211446899920702,
-0.00971644464880228,
-0.15765045583248138,
0.014074836857616901,
0.0... | 0.076328 |
Kubernetes will validate image credentials for every image that requires credentials to be pulled, even if that image is already present on the node. This validation ensures that images in a Pod request which have not been successfully pulled with the provided credentials must re-pull the images from the registry. Addi... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/containers/images.md | main | kubernetes | [
-0.017540238797664642,
0.019007403403520584,
0.05895112082362175,
-0.0029056973289698362,
-0.011348706670105457,
0.0014506167499348521,
-0.0038578028324991465,
-0.04497557133436203,
0.10027432441711426,
-0.01021972019225359,
0.009307263419032097,
-0.04938646778464317,
0.05726510286331177,
... | 0.060425 |
time per namespace. {{< /note >}} #### Referring to `imagePullSecrets` on a Pod Now, you can create pods which reference that secret by adding the `imagePullSecrets` section to a Pod definition. Each item in the `imagePullSecrets` array can only reference one Secret in the same namespace. For example: ```shell cat < po... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/containers/images.md | main | kubernetes | [
0.015756450593471527,
-0.007587738335132599,
0.025156281888484955,
0.022619787603616714,
0.005341572221368551,
-0.03726803511381149,
0.039429496973752975,
0.04090939462184906,
0.0711616650223732,
0.02465813234448433,
0.04176755249500275,
-0.08999929577112198,
0.000055136901210062206,
0.006... | 0.121544 |
[pulling an Image from a Private Registry](/docs/tasks/configure-pod-container/pull-image-private-registry). | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/containers/images.md | main | kubernetes | [
0.035607125610113144,
0.009781175293028355,
0.001680468674749136,
0.004834657534956932,
0.10867457836866379,
0.004958470817655325,
0.010907373391091824,
0.041745059192180634,
-0.046432092785835266,
0.03951175510883331,
0.025952497497200966,
-0.010347399860620499,
-0.05352577194571495,
0.06... | 0.149327 |
{{< feature-state for\_k8s\_version="v1.20" state="stable" >}} This page describes the RuntimeClass resource and runtime selection mechanism. RuntimeClass is a feature for selecting the container runtime configuration. The container runtime configuration is used to run a Pod's containers. ## Motivation You can set a di... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/containers/runtime-class.md | main | kubernetes | [
-0.01773727312684059,
0.06200088560581207,
0.048897404223680496,
0.010263793170452118,
0.01875397190451622,
-0.020345428958535194,
-0.054854441434144974,
0.0411355085670948,
-0.06860783696174622,
-0.053197186440229416,
-0.029639020562171936,
-0.03916306421160698,
-0.024873148649930954,
-0.... | 0.170663 |
table](https://github.com/cri-o/cri-o/blob/master/docs/crio.conf.5.md#crioruntime-table): ``` [crio.runtime.runtimes.${HANDLER\_NAME}] runtime\_path = "${PATH\_TO\_BINARY}" ``` See CRI-O's [config documentation](https://github.com/cri-o/cri-o/blob/master/docs/crio.conf.5.md) for more details. ## Scheduling {{< feature-... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/containers/runtime-class.md | main | kubernetes | [
-0.013055692426860332,
0.005185682326555252,
0.0076946960762143135,
0.04496648907661438,
0.03094789944589138,
-0.021336879581212997,
0.008182326331734657,
0.012867596000432968,
-0.08420559018850327,
-0.038370974361896515,
-0.052415017038583755,
-0.08391673117876053,
0.007432933431118727,
0... | 0.252191 |
This page describes the resources available to Containers in the Container environment. ## Container environment The Kubernetes Container environment provides several important resources to Containers: \* A filesystem, which is a combination of an [image](/docs/concepts/containers/images/) and one or more [volumes](/do... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/containers/container-environment.md | main | kubernetes | [
0.032320890575647354,
0.03135210648179054,
0.011247481219470501,
0.01753336936235428,
0.004818460438400507,
-0.030037056654691696,
0.00862288847565651,
0.009592722170054913,
0.05116761848330498,
-0.005062889773398638,
-0.05633564293384552,
-0.05490761622786522,
-0.015762517228722572,
-0.05... | 0.171631 |
This page describes how kubelet managed Containers can use the Container lifecycle hook framework to run code triggered by events during their management lifecycle. ## Overview Analogous to many programming language frameworks that have component lifecycle hooks, such as Angular, Kubernetes provides Containers with lif... | https://github.com/kubernetes/website/blob/main/content/en/docs/concepts/containers/container-lifecycle-hooks.md | main | kubernetes | [
0.012904960662126541,
0.051231998950242996,
0.02483755722641945,
0.013197026215493679,
-0.006919573061168194,
0.0023636012338101864,
-0.004145714454352856,
-0.0424649715423584,
0.09734417498111725,
0.020101619884371758,
-0.012250884436070919,
-0.008464273996651173,
-0.05366252735257149,
-0... | 0.167798 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.