dmosk / k8size

Kubernetes ਇਕਾਈ ਕਨਵਰਟਰ

CPU ਤੇ ਮੈਮੋਰੀ ਨੂੰ ਮੈਨੀਫੈਸਟ ਮੁੱਲਾਂ ਵਿੱਚ ਬਦਲੋ, 500m/256Mi ਪੇਸਟ ਕਰੋ, Mi ਬਨਾਮ M ਚੇਤਾਵਨੀ ਵੇਖੋ, ਲਿੰਕ ਸਾਂਝਾ ਕਰੋ ਤੇ QoS ਜਾਂਚੋ। ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ — API ਨਹੀਂ।

requests — ਸ਼ੈਡਿਊਲਿੰਗ ਲਈ ਘੱਟੋ-ਘੱਟ ਗਾਰੰਟੀ; limits — ਉੱਪਰੀ ਸੀਮਾ। ਆਮ ਤੌਰ ਤੇ requests ≤ limits; ਬਰਾਬਰ → Guaranteed QoS। ਡੌਕ: Resource Management।

CPU

ਮੈਮੋਰੀ

QoS ਵਰਗ (ਇੱਕ ਕੰਟੇਨਰ)

ਇੱਕ ਕੰਟੇਨਰ ਦਾ ਸਰਲ ਦ੍ਰਿਸ਼ — ਕਲੱਸਟਰ ਸਾਈਜ਼ਿੰਗ ਸਲਾਹਕਾਰ ਨਹੀਂ।

ਵਰਗ: BestEffort

k8size ਕਿਉਂ ਵਰਤੋ

  • ਚੇਤਾਵਨੀ, ਸਾਂਝਾ ਅਤੇ QoS. ਦਸ਼ਮਲਵ ਇਕਾਈਆਂ ਤੇ Mi/Gi; ?cpu=&mem= ਕਾਪੀ; ਇੱਕ ਕੰਟੇਨਰ QoS।
  • Cores ↔ millicores. ਦਸ਼ਮਲਵ cores ਜਾਂ ਪੂਰਨ millicores ਭਰੋ ਅਤੇ ਦੋਵੇਂ ਰੂਪ ਤੇ cpu: "500m" ਵਰਗਾ YAML ਵੇਖੋ।
  • ਬਾਈਨਰੀ ਬਨਾਮ ਦਸ਼ਮਲਵ ਮੈਮੋਰੀ. Mi/Gi (1024) ਨੂੰ M/G/MB/GB (1000) ਤੋਂ ਵੱਖ ਰੱਖੋ ਤਾਂ ਜੋ 256Mi ਨੂੰ 256M ਨਾ ਸਮਝੋ।
  • ਤਿਆਰ YAML. requests ਤੇ limits ਲਈ cpu ਤੇ memory ਕਾਪੀ ਕਰੋ।
  • ਛੋਟੀ requests vs limits ਟਿਪ. Guaranteed QoS ਦੀ ਯਾਦ — ਸਾਈਜ਼ਿੰਗ ਸਲਾਹਕਾਰ ਨਹੀਂ।
  • ਉਦਾਹਰਨ ਬਟਨ. ਆਮ ਮੁੱਲ ਭਰਦੇ ਹਨ: 100m, 500m, 256Mi, 1Gi।
  • ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ. ਕੋਈ API ਨਹੀਂ; ਮੁੱਲ ਡਿਵਾਈਸ ਨਹੀਂ ਛੱਡਦੇ।
  • ਮੁਫ਼ਤ ਤੇ ਬਹੁਭਾਸ਼ੀ. ਖਾਤਾ ਨਹੀਂ; ਹਰ ਲੋਕੇਲ ਲਈ UI ਤੇ SEO।

Kubernetes ਇਕਾਈਆਂ ਕਿਵੇਂ ਬਦਲੀਏ

  1. CPU ਜਾਂ ਮੈਮੋਰੀ ਭਾਗ ਖੋਲ੍ਹੋ।
  2. ਨੰਬਰ ਲਿਖੋ ਤੇ ਇਕਾਈ ਚੁਣੋ।
  3. ਲਿਖਦਿਆਂ ਬਰਾਬਰੀਆਂ ਤੇ YAML ਵੇਖੋ।
  4. ਉਦਾਹਰਨ ਵਰਤੋ ਤੇ ਲੋੜੀਂਦਾ ਸਨਿੱਪਟ ਕਾਪੀ ਕਰੋ।

ਇਕਾਈਆਂ, requests ਤੇ limits

Kubernetes CPU ਨੂੰ cores ਜਾਂ millicores (m) ਵਜੋਂ ਤੇ ਮੈਮੋਰੀ ਨੂੰ ਬਾਈਨਰੀ (Ki/Mi/Gi/Ti) ਜਾਂ ਦਸ਼ਮਲਵ (k/M/G/T) ਪਿਛੇਤਰਾਂ ਨਾਲ ਲੈਂਦਾ ਹੈ। ਟੂਲ ਸਿਰਫ਼ ਮਾਤਰਾ ਬਦਲਦਾ ਹੈ।

ਸੁਝਾਅ:

  • 1 core = 1000 millicores; 500m = 0.5.
  • Mi/Gi 1024 ਦੀਆਂ ਘਾਤਾਂ ਹਨ; M/G/MB/GB 1000 ਦੀਆਂ।
  • requests ਸ਼ੈਡਿਊਲਿੰਗ ਲਈ; limits ਵਰਤੋਂ ਰੋਕਦੇ ਹਨ — ਅਕਸਰ requests ≤ limits।
  • CPU ਤੇ ਮੈਮੋਰੀ ਤੇ ਬਰਾਬਰ requests ਤੇ limits = Guaranteed QoS।
  • ਟੀਮ ਵਿੱਚ ਇੱਕ ਇਕਾਈ ਸਟਾਈਲ ਰੱਖੋ ਤਾਂ ਜੋ Mi ਤੇ M ਨਾ ਰਲਣ।
  • ਇਹ ਵਰਕਲੋਡ ਸਾਈਜ਼ਿੰਗ ਸਲਾਹਕਾਰ ਨਹੀਂ ਹੈ।

ਕਿਸ ਲਈ

  • Deployment ਸੋਧ ਤੋਂ ਪਹਿਲਾਂ millicores ਤੇ cores ਜਾਂਚ;
  • ਚਾਰਟ ਜਾਂ ਮੈਨੀਫੈਸਟ ਪੜ੍ਹਦਿਆਂ Mi ਤੇ M ਦੀ ਤੁਲਨਾ;
  • requests/limits ਲਈ YAML ਟੁਕੜੇ ਤਿਆਰ ਕਰਨਾ;
  • ਬਾਈਨਰੀ ਤੇ ਦਸ਼ਮਲਵ ਪਿਛੇਤਰਾਂ ਦਾ ਫ਼ਰਕ ਸਿਖਾਉਣਾ;
  • ਰਿਵਿਊ ਜਾਂ ਘਟਨਾ ਵੇਲੇ ਤੇਜ਼ ਜਾਂਚ।

ਅਕਸਰ ਪੁੱਛੇ ਜਾਣ ਵਾਲੇ ਸਵਾਲ

CPU ਤੇ m ਦਾ ਅਰਥ?

ਮਿਲੀਕੋਰ: 1000m = ਇੱਕ ਪੂਰਾ core। 0.5 = 500m।

ਕੀ Mi = M ਜਾਂ MB?

ਨਹੀਂ। Mi = 1024² ਬਾਈਟ; M/MB = 1000²।

ਕੀ ਮੁੱਲ ਅੱਪਲੋਡ ਹੁੰਦੇ ਹਨ?

ਨਹੀਂ। ਰੂਪਾਂਤਰਨ ਸਿਰਫ਼ ਬ੍ਰਾਊਜ਼ਰ ਵਿੱਚ।

ਸਹੀ requests ਸੁਝਾਏਗਾ?

ਨਹੀਂ। ਸਿਰਫ਼ ਇਕਾਈ ਰੂਪਾਂਤਰਨ ਤੇ ਛੋਟੀ ਟਿਪ।

CPU YAML ਕਿਹੜਾ?

500m ਤੇ 0.5 ਦੋਵੇਂ ਠੀਕ; ਇੱਕ ਸਟਾਈਲ ਰੱਖੋ।

KB/MB/GB?

ਹਾਂ, 1000-ਆਧਾਰਿਤ ਉਪਨਾਮ K/M/G/T ਨਾਲ।

Ti ਤੇ T?

Ti = 1024⁴; T/TB = 1000⁴। ਦੋਵੇਂ ਟੇਬਲ ਵਿੱਚ।

Guaranteed QoS ਲਾਜ਼ਮੀ?

ਨਹੀਂ। ਜਦੋਂ requests = limits ਹੋਣ ਤਾਂ ਇੱਕ QoS ਵਰਗ।

ਪੂਰਾ ਮੈਨੀਫੈਸਟ ਐਡੀਟਰ?

ਨਹੀਂ। ਸਿਰਫ਼ ਇਕਾਈਆਂ ਤੇ ਛੋਟੇ YAML।

ਕੀ ਫ਼ੀਸ ਹੈ?

ਨਹੀਂ — ਮੁਫ਼ਤ, ਬਿਨਾਂ ਰਜਿਸਟਰ।