Skip to main content
Back to Blog
KarpenterARCKubernetesEKSGitHub ActionsDevOps

Building Elastic GitHub Actions Runners with ARC and Karpenter on EKS

EKS ပေါ်မှာ ARC နဲ့ Karpenter ကို တွဲသုံးပြီး လိုအပ်သလောက် တိုးချဲ့နိုင်တဲ့ GitHub Actions runners တည်ဆောက်ပုံ၊ configuration၊ အားသာချက်၊ အားနည်းချက်နဲ့ tuning လုပ်နိုင်မယ့် နည်းလမ်းများ။

18 min read

ARC နဲ့ Karpenter က runner pods နဲ့ EC2 nodes တွေကို လိုအပ်သလောက် တိုးချဲ့ပေးပုံ

CI jobs တွေက တစ်နေ့လုံး တူညီတဲ့နှုန်းနဲ့ ဝင်လာတာ မဟုတ်ပါဘူး။ တချို့အချိန်မှာ build အများကြီး တစ်ပြိုင်တည်း run ဖို့ လိုပြီး၊ တချို့အချိန်မှာတော့ job တစ်ခုမှ မရှိတတ်ပါဘူး။ အမြဲဖွင့်ထားတဲ့ runner server ကို သုံးမယ်ဆိုရင် အလုပ်မရှိချိန်မှာလည်း စရိတ်ကုန်နေပြီး၊ အလုပ်များလာချိန်မှာ capacity မလောက်လို့ queue စောင့်ရနိုင်ပါတယ်။

EKS ပေါ်မှာ Actions Runner Controller (ARC) နဲ့ Karpenter ကို တွဲသုံးတဲ့အခါ ဒီလို အပြောင်းအလဲရှိတဲ့ CI demand ကို လိုက်ပြီး runner pods နဲ့ EC2 nodes တွေကို တိုးချဲ့ပေးနိုင်ပါတယ်။ Jobs တွေ ပြီးသွားရင် runner pods တွေကို ဖယ်ရှားပြီး မလိုတော့တဲ့ CI nodes တွေကိုလည်း ပြန်လျှော့နိုင်ပါတယ်။

ဒီဆောင်းပါးမှာ အဲဒီစနစ်ရဲ့ အလုပ်လုပ်ပုံကို အရင်ရှင်းပြပြီး၊ EKS အတွက် လိုအပ်တဲ့ ပြင်ဆင်မှုတွေ၊ configuration ဥပမာတွေ၊ အားသာချက်နဲ့ အားနည်းချက်တွေကို ဆက်လက်ဖော်ပြထားပါတယ်။ နောက်ဆုံးမှာ workload ကြီးလာတဲ့အခါ ဘယ် settings တွေကို ဘာကြောင့် ပြင်သင့်သလဲဆိုတာ ဆွေးနွေးထားပါတယ်။ Kubernetes ရဲ့ pod၊ node နဲ့ scheduling အခြေခံကို သိထားတဲ့ engineers တွေအတွက် ရည်ရွယ်ပါတယ်။

နမူနာတွေမှာ modern ARC runner scale sets နဲ့ Karpenter ရဲ့ AWS provider ကို အသုံးပြုထားပါတယ်။ Chart version ဥပမာတွေက ARC 0.15.1 နဲ့ Karpenter 1.9.2 ဖြစ်ပါတယ်။ မိမိအသုံးပြုမယ့် EKS version နဲ့ ကိုက်ညီတဲ့ chart၊ CRD နဲ့ AMI versions တွေကို တွဲဖက်ရွေးချယ်ဖို့ လိုပါတယ်။

ARC နဲ့ Karpenter က ဘာကိုယ်စီ လုပ်ပေးသလဲ#

ဒီ architecture ကို နားလည်ဖို့ အဓိကအချက်က runner အရေအတွက်နဲ့ node အရေအတွက်ကို သီးခြားစီ ထိန်းချုပ်ထားခြင်း ဖြစ်ပါတယ်။

ARC က GitHub Actions jobs တွေအတွက် runner pods တွေကို စီမံပေးပါတယ်။ ဒီနေရာမှာ runner ဆိုတာ workflow ရဲ့ steps တွေကို တကယ် execute လုပ်ပေးတဲ့ process ဖြစ်ပြီး၊ runner scale set ဆိုတာ configuration တူညီတဲ့ runners အစုအဝေး ဖြစ်ပါတယ်။ Ephemeral runner တစ်ခုက job တစ်ခုကို လုပ်ဆောင်ပြီးတာနဲ့ ဖယ်ရှားခံရပါတယ်။ နောက် job အတွက် runner အသစ်တစ်ခု အသုံးပြုပါတယ်။

Karpenter ကတော့ အဲဒီ pods တွေ run ဖို့ လိုအပ်တဲ့ EC2 capacity ကို စီမံပေးပါတယ်။ Kubernetes scheduler က pod တစ်ခုကို လက်ရှိ nodes တွေပေါ်မှာ နေရာမချနိုင်တဲ့အခါ Karpenter က pod ရဲ့ resource requests နဲ့ scheduling constraints တွေကို ကြည့်ပြီး သင့်တော်တဲ့ node တစ်ခု ဖန်တီးပေးနိုင်ပါတယ်။

Componentအဓိကတာဝန်
ARC controllerRunner scale set နဲ့ ephemeral runner resources တွေကို စီမံခြင်း
ARC listenerGitHub က job demand ကို လက်ခံပြီး runner အရေအတွက် ပြောင်းလဲဖို့ ချိတ်ဆက်ပေးခြင်း
Kubernetes schedulerPod နဲ့ ကိုက်ညီပြီး resource လုံလောက်တဲ့ node ကို ရွေးခြင်း
Karpenterလိုအပ်တဲ့ EC2 nodes တွေ ဖန်တီးခြင်းနဲ့ မလိုတော့တဲ့ capacity ကို ပြန်လျှော့ခြင်း

အဲဒါကြောင့် ARC က runner pods တွေ ထုတ်ပေးနိုင်ပေမယ့် EC2 nodes ကို သူကိုယ်တိုင် ဖန်တီးပေးတာ မဟုတ်ပါဘူး။ Karpenter ကလည်း GitHub jobs တွေကို တိုက်ရိုက် နားထောင်နေတာ မဟုတ်ဘဲ Kubernetes pods တွေရဲ့ လိုအပ်ချက်ကနေ capacity ကို ဆုံးဖြတ်ပါတယ်။

Job တစ်ခု ဝင်လာတဲ့အခါ ဘာတွေ ဖြစ်သလဲ#

CI pool မှာ runner နဲ့ node တစ်ခုမှ မရှိသေးတဲ့အချိန်ကနေ စဉ်းစားကြည့်ပါ။

GitHub Actions job
    |
    v
ARC listener receives job demand
    |
    v
ARC creates an ephemeral runner pod
    |
    v
Pod is Pending: no eligible node has enough capacity
    |
    v
Karpenter creates a NodeClaim and launches an EC2 instance
    |
    v
Node joins EKS; runner becomes ready
    |
    v
Runner executes the job
    |
    v
Job completes; runner pod is removed
    |
    v
Empty CI node is consolidated after the configured delay

NodeClaim ဆိုတာ Karpenter က node တစ်ခုအတွက် လိုအပ်ချက်နဲ့ lifecycle ကို ကိုယ်စားပြုထားတဲ့ Kubernetes resource ဖြစ်ပါတယ်။ EC2 instance က EKS ထဲ join ပြီး node က Ready ဖြစ်လာတဲ့အခါမှ runner pod ကို schedule လုပ်နိုင်မှာပါ။

ဒီအဆင့်အားလုံးကို job တိုင်းအတွက် အစကနေ ပြန်လုပ်ရတာတော့ မဟုတ်ပါဘူး။ CI node တစ်ခုက ရှိနေသေးပြီး resource လည်း လုံလောက်မယ်ဆိုရင် runner အသစ်က အဲဒီ node ပေါ်မှာပဲ run နိုင်ပါတယ်။ Job ပြီးချင်း node ကို မဖယ်ရှားဘဲ ခဏစောင့်ထားခြင်းက နောက် job အတွက် node အသစ်ဖွင့်ရတဲ့ အချိန်ကို သက်သာစေနိုင်ပါတယ်။

Controllers အတွက် capacity နဲ့ CI capacity ကို ခွဲထားခြင်း#

Runner nodes တွေကို zero အထိ လျှော့ချချင်တယ်ဆိုရင်တောင် controllers တွေက ဆက်ပြီး run နေဖို့ လိုပါတယ်။ Karpenter controller မရှိရင် node အသစ် မဖန်တီးနိုင်သလို၊ ARC listener မရှိရင်လည်း job demand ကို လက်ခံပြီး runner တိုးပေးနိုင်မှာ မဟုတ်ပါဘူး။

ဒါကြောင့် placement ကို အောက်ပါအတိုင်း ခွဲထားနိုင်ပါတယ်။

CapacityRun မယ့် components
အမြဲရှိနေမယ့် EKS managed nodesKarpenter controller၊ ARC controller၊ ARC listener နဲ့ လိုအပ်တဲ့ cluster services
Karpenter က ဖန်တီးမယ့် CI nodesRunner pods၊ Docker sidecars နဲ့ node တိုင်းမှာ လိုအပ်တဲ့ agents

Controllers တွေကို managed nodes ပေါ်မှာပဲ ထားချင်ရင် eks.amazonaws.com/nodegroup label ကို အခြေခံတဲ့ required node affinity ကို အသုံးပြုနိုင်ပါတယ်။ အဲဒီ nodes တွေမှာ controllers အတွက် CPU နဲ့ memory လုံလောက်ရပါမယ်။ Availability လိုအပ်ချက်အလိုက် node အရေအတွက်နဲ့ placement ကိုလည်း စီစဉ်ထားသင့်ပါတယ်။

Scale to zero ဆိုတာ ဒီမှာ CI runner capacity ကို ပြောတာပါ။ EKS cluster တစ်ခုလုံးနဲ့ controller capacity အားလုံးကို ပိတ်လိုက်တာ မဟုတ်ပါဘူး။

Taint နဲ့ node selector ကို ဘာကြောင့် တွဲသုံးသလဲ#

CI nodes တွေမှာ အောက်ပါ taint ကို သတ်မှတ်ထားနိုင်ပါတယ်။

key: ci-runner
value: "true"
effect: NoSchedule

ဒီ taint ကို tolerate မလုပ်တဲ့ application pods တွေက CI nodes ပေါ်ကို ရောက်လာမှာ မဟုတ်ပါဘူး။ ဒါပေမယ့် runner မှာ toleration ထည့်ပေးထားရုံနဲ့ CI node ပေါ်ကိုပဲ ရောက်မယ်လို့ မသတ်မှတ်နိုင်ပါဘူး။ Toleration က အဲဒီ node ပေါ်မှာ run ခွင့်ရှိတယ် လို့ပဲ ပြောတာပါ။

Runner ကို CI pool ပေါ်မှာပဲ run စေဖို့ nodeSelector ဒါမှမဟုတ် required node affinity လည်း လိုပါတယ်။ ဒီဥပမာမှာ karpenter.sh/nodepool: ci-runner-amd64 ကို selector အဖြစ် အသုံးပြုပါမယ်။ Taint က တခြား pods တွေကို ကန့်သတ်ပြီး၊ selector က runner ကို သတ်မှတ်ထားတဲ့ pool ဆီ ညွှန်ပေးတာ ဖြစ်ပါတယ်။

စတင်အသုံးပြုဖို့ capacity profile တစ်ခု#

အစမှာ concurrency နည်းနည်းနဲ့ စတင်ပြီး job lifecycle တစ်ခုလုံး အလုပ်လုပ်ကြောင်း စစ်ဆေးနိုင်ပါတယ်။ အောက်ပါ values တွေက သေးငယ်တဲ့ စမ်းသပ်မှုအတွက် နမူနာဖြစ်ပြီး workload အားလုံးအတွက် သတ်မှတ်ချက်တော့ မဟုတ်ပါဘူး။

Settingနမူနာ valueရည်ရွယ်ချက်
Idle runnersminRunners: 0Job မရှိချိန်မှာ runner မထားရန်
Maximum runnersmaxRunners: 1တစ်ချိန်မှာ job တစ်ခုသာ run ရန်
Instance typesc6i.large, c6i.xlargex86-64 instance sizes နှစ်မျိုးကနေ ရွေးရန်
Capacity typeOn-Demandစတင်ချိန်မှာ Spot interruption ကို ထည့်မစဉ်းစားရသေးစေရန်
NodePool limits4 vCPU၊ 8 GiBPool က ဖန်တီးနိုင်တဲ့ စုစုပေါင်း capacity ကို ကန့်သတ်ရန်
ConsolidationWhenEmpty, 5mJob မရှိတော့တဲ့ node ကို ခဏစောင့်ပြီးမှ ဖယ်ရှားရန်
Container data volumeEncrypted gp3၊ 100 GiBContainer images နဲ့ build data အတွက် နေရာပေးရန်

maxRunners: 1 ဆိုရင် ဒီ scale set ကို သုံးတဲ့ repositories အားလုံးက capacity တစ်ခုတည်းကို မျှဝေသုံးရမှာပါ။ Repository တစ်ခုမှာ job run နေချိန် နောက် repository ရဲ့ job က စောင့်ရနိုင်ပါတယ်။ Workflow ရဲ့ concurrency setting က သီးခြားဖြစ်လို့ runner အရေအတွက် ကန့်သတ်ချက်ကို မကျော်နိုင်ပါဘူး။

NodePool limits နဲ့ runner limits ကလည်း တာဝန်မတူပါဘူး။ maxRunners က runners အရေအတွက်ကို ထိန်းပြီး၊ NodePool limits က nodes တွေရဲ့ စုစုပေါင်း resource ကို ထိန်းပါတယ်။ Karpenter ရဲ့ limit checks တွေက eventually consistent ဖြစ်တဲ့အတွက် တစ်ပြိုင်တည်း node အများကြီး ဖန်တီးချိန်မှာ limit ကို ခေတ္တကျော်နိုင်ပါတယ်။ ဒါကြောင့် NodePool limit ကို တိကျတဲ့ အသုံးစရိတ် budget အဖြစ် မယူဆသင့်ပါဘူး။ NodePool limits

EKS နဲ့ AWS ဘက်မှာ ပြင်ဆင်ရမယ့်အရာများ#

Karpenter က EC2 instance ဖွင့်နိုင်ရုံနဲ့ runner အလုပ်လုပ်ဖို့ မလုံလောက်ပါဘူး။ Node က EKS ထဲ join နိုင်ရမယ်၊ သင့်တော်တဲ့ network ထဲမှာ ရှိရမယ်၊ GitHub နဲ့လည်း ဆက်သွယ်နိုင်ရပါမယ်။

လိုအပ်ချက်အသုံးပြုပုံ
Karpenter controller IAM roleEC2 node lifecycle ကို စီမံဖို့ scoped permissions ပေးခြင်း
Karpenter node IAM roleNode က EKS နဲ့ လိုအပ်တဲ့ AWS services တွေကို အသုံးပြုခြင်း
EKS node authorizationNode role အသစ်ကို cluster ထဲ join ခွင့်ပေးခြင်း
Subnet နဲ့ security group selectionNode တွေကို သင့်တော်တဲ့ network ထဲ ဖန်တီးခြင်း
Network connectivityEKS API၊ GitHub နဲ့ လိုအပ်တဲ့ image endpoints တွေဆီ ဆက်သွယ်နိုင်ခြင်း
Interruption queueAWS lifecycle events တွေကို Karpenter ဆီ ပို့ခြင်း

Controller identity အတွက် IRSA သို့မဟုတ် EKS Pod Identity ကို အသုံးပြုနိုင်ပါတယ်။ Controller role နဲ့ node role ကို သီးခြားထားပြီး ရွေးချယ်ထားတဲ့ Karpenter version ရဲ့ permissions အတိုင်း configure လုပ်ပါ။ API-based node authorization သုံးတဲ့ cluster မှာ node role အတွက် EC2_LINUX access entry ကို ပြင်ဆင်ထားဖို့ လိုပါတယ်။

Subnet နဲ့ security group တွေကို karpenter.sh/discovery ကဲ့သို့ tag နဲ့ ရွေးနိုင်ပါတယ်။ ဒီ tag က ဘယ် resources တွေကို ရွေးမလဲဆိုတာ သတ်မှတ်ပေးတာဖြစ်ပြီး network access ကို သူ့ဘာသာ ဖွင့်ပေးတာ မဟုတ်ပါဘူး။ Routes နဲ့ security-group rules တွေက node နဲ့ pods တွေရဲ့ လိုအပ်တဲ့ traffic ကို ခွင့်ပြုထားရပါမယ်။

EventBridge နဲ့ SQS က ဘာအတွက်လဲ#

Interruption handling အတွက် event flow က အောက်ပါအတိုင်း ဖြစ်ပါတယ်။

AWS lifecycle event -> EventBridge rule -> SQS queue -> Karpenter

EventBridge က သက်ဆိုင်ရာ AWS events တွေကို SQS queue ဆီ ပို့ပြီး Karpenter က queue ထဲက notifications တွေကို ဖတ်ပါတယ်။ Supported interruption events တွေ ရောက်လာတဲ့အခါ သက်ဆိုင်ရာ node ကို drain လုပ်တာနဲ့ replacement capacity ပြင်ဆင်တာတွေကို လုပ်ဆောင်နိုင်ပါတယ်။ Spot interruption အပြင် scheduled maintenance လို On-Demand instances နဲ့ သက်ဆိုင်တဲ့ events တွေကြောင့်လည်း ဒီလမ်းကြောင်းက အသုံးဝင်ပါတယ်။

ဒါပေမယ့် interruption handling ရှိလို့ build တိုင်း မပျက်ဘူးလို့ အာမခံလို့ မရပါဘူး။ AWS က ပေးတဲ့အချိန်ထက် build က ပိုကြာနေရင် job ကို retry လုပ်ရနိုင်ပါတယ်။ Spot rebalance recommendation နဲ့ တကယ့် interruption notice ကို Karpenter က ကိုင်တွယ်ပုံလည်း မတူပါဘူး။ Karpenter interruption handling

ဒီ queue က လူဆီ alert ပို့ပေးတဲ့ စနစ် မဟုတ်ပါဘူး။ Job failures နဲ့ capacity ပြဿနာတွေကို သိနိုင်ဖို့ monitoring နဲ့ notification rules တွေကို သီးခြားသတ်မှတ်ရပါမယ်။

NodePool နဲ့ EC2NodeClass ကို သတ်မှတ်ခြင်း#

Karpenter configuration မှာ ဒီ resources နှစ်ခုရဲ့ တာဝန်ကို ခွဲနားလည်ထားရင် ပြင်ဆင်ရလွယ်ပါတယ်။

  • NodePool က ဘယ်လို capacity ကို ဖန်တီးခွင့်ရှိသလဲဆိုတာ သတ်မှတ်ပါတယ်။ Instance types၊ architecture၊ capacity limits၊ taints နဲ့ consolidation policy တွေ ပါဝင်ပါတယ်။
  • EC2NodeClass က AWS ပေါ်မှာ node ကို ဘယ်လို ဖန်တီးမလဲဆိုတာ သတ်မှတ်ပါတယ်။ AMI၊ IAM role၊ subnets၊ security groups နဲ့ disks တွေ ပါဝင်ပါတယ်။

NodePool ဥပမာ#

apiVersion: karpenter.sh/v1
kind: NodePool
metadata:
  name: ci-runner-amd64
spec:
  disruption:
    consolidationPolicy: WhenEmpty
    consolidateAfter: 5m
  limits:
    cpu: "4"
    memory: 8Gi
  template:
    spec:
      nodeClassRef:
        group: karpenter.k8s.aws
        kind: EC2NodeClass
        name: ci-runner-amd64
      requirements:
        - key: node.kubernetes.io/instance-type
          operator: In
          values: ["c6i.large", "c6i.xlarge"]
        - key: kubernetes.io/arch
          operator: In
          values: ["amd64"]
        - key: kubernetes.io/os
          operator: In
          values: ["linux"]
        - key: karpenter.sh/capacity-type
          operator: In
          values: ["on-demand"]
      taints:
        - key: ci-runner
          value: "true"
          effect: NoSchedule

ဒီ pool က Linux amd64 On-Demand nodes တွေကိုပဲ ဖန်တီးခွင့်ပေးထားပါတယ်။ nodeClassRef က အောက်မှာ သတ်မှတ်မယ့် EC2NodeClass ကို ချိတ်ဆက်ထားပါတယ်။

WhenEmpty က workload pods မရှိတော့တဲ့ nodes တွေကို consolidation လုပ်ဖို့ ရွေးချယ်ထားတာပါ။ consolidateAfter: 5m က node အလွတ်ဖြစ်ပြီးနောက် ခဏစောင့်ပေးစေပါတယ်။ Active job ရှိနေတဲ့ node ကို utilization နည်းလို့ဆိုပြီး consolidation လုပ်ဖို့ မရည်ရွယ်ပါဘူး။ သို့သော် node expiration၊ maintenance နဲ့ AWS interruption လို တခြား node lifecycle events တွေကတော့ ရှိနေဆဲပါ။

EC2NodeClass ဥပမာ#

အောက်ပါ configuration က Bottlerocket node အတွက် နမူနာ ဖြစ်ပါတယ်။ ami-0123456789abcdef0 က placeholder ဖြစ်လို့ မိမိရဲ့ AWS region၊ EKS version နဲ့ CPU architecture အတွက် ကိုက်ညီတဲ့ AMI ID နဲ့ အစားထိုးရပါမယ်။ IAM role နဲ့ discovery tags တွေကလည်း ကြိုတင်ပြင်ဆင်ထားတဲ့ resources နဲ့ ကိုက်ညီရပါမယ်။

apiVersion: karpenter.k8s.aws/v1
kind: EC2NodeClass
metadata:
  name: ci-runner-amd64
spec:
  amiFamily: Bottlerocket
  amiSelectorTerms:
    - id: ami-0123456789abcdef0 # Example only: replace before applying
  role: demo-staging-karpenter-node
  subnetSelectorTerms:
    - tags:
        karpenter.sh/discovery: demo-eks-staging
  securityGroupSelectorTerms:
    - tags:
        karpenter.sh/discovery: demo-eks-staging
  blockDeviceMappings:
    - deviceName: /dev/xvda
      ebs:
        volumeSize: 4Gi
        volumeType: gp3
        encrypted: true
        deleteOnTermination: true
    - deviceName: /dev/xvdb
      ebs:
        volumeSize: 100Gi
        volumeType: gp3
        encrypted: true
        deleteOnTermination: true
  tags:
    karpenter.sh/discovery: demo-eks-staging

Bottlerocket အတွက် root volume နဲ့ container data volume ကို သီးခြားသတ်မှတ်ထားပါတယ်။ 100 GiB data volume က နမူနာသာဖြစ်ပြီး build context၊ Docker layers နဲ့ တစ်ပြိုင်တည်း run မယ့် jobs ပမာဏအလိုက် ချိန်ညှိနိုင်ပါတယ်။ Node ကို ဖယ်ရှားတဲ့အခါ ဒီဥပမာရဲ့ volumes တွေကိုပါ ဖျက်မှာဖြစ်လို့ build artifacts တွေကို node disk ပေါ်မှာ အမြဲသိမ်းထားလို့ မရပါဘူး။

AMI ကို ID နဲ့ pin လုပ်ထားခြင်းက node အသစ်တိုင်းမှာ ဘယ် image သုံးမလဲဆိုတာ တိကျစေပါတယ်။ တစ်ဖက်မှာ image updates တွေကို စစ်ဆေးပြီး AMI ID ကို ပုံမှန်တင်ပေးရတဲ့ တာဝန်လည်း ရှိလာပါတယ်။ EC2NodeClass configuration

GitHub App၊ runner group နဲ့ scale set#

AWS ဘက်က capacity အဆင်သင့်ဖြစ်ပြီးနောက် GitHub ဘက်က authentication နဲ့ access ကို သတ်မှတ်ရပါမယ်။ ဒီနေရာမှာ chart name၊ scale-set name နဲ့ runner-group name ကို ခွဲထားဖို့ လိုပါတယ်။

အမည်ဥပမာအဓိပ္ပာယ်
Helm chartgha-runner-scale-setARC upstream package ရဲ့ အမည်
Runner scale setdemo-staging-runnerWorkflow က ရွေးချယ်သုံးမယ့် runner pool
Runner groupdemo-stagingဘယ် repositories နဲ့ workflows တွေ သုံးခွင့်ရှိသလဲဆိုတဲ့ access policy

Runner group တစ်ခုထဲမှာ scale sets အများအပြား ထားနိုင်ပါတယ်။ Group အတွင်းမှာ scale-set names တွေ မထပ်ရပါဘူး။ Access policy တူညီတဲ့ small-build နဲ့ large-build pools တွေကို group တစ်ခုတည်းမှာထားပြီး scale-set name နဲ့ ခွဲသုံးနိုင်ပါတယ်။ Runner scale-set configuration

Organization scope အတွက် GitHub App#

ဒီဥပမာမှာ runners တွေကို GitHub organization အဆင့်မှာ register လုပ်မှာ ဖြစ်ပါတယ်။ Organization-owned GitHub App ကို organization ထဲ install လုပ်ပြီး အောက်ပါ permissions တွေ ပြင်ဆင်ပါ။

  • Organization permission: Self-hosted runners — Read and write
  • Repository permission: Metadata — Read-only

Repository scope မှာ register လုပ်တဲ့အခါ လိုအပ်တဲ့ Repository Administration permission က organization scope အတွက် မလိုအပ်ပါဘူး။ App ID၊ installation ID နဲ့ private key ကို အသုံးပြုပြီး ARC က GitHub API ကို authenticate လုပ်ပါတယ်။ ARC authentication

အဲဒီ credentials တွေပါတဲ့ Kubernetes Secret ကို runner scale set တင်မယ့် namespace ထဲမှာ ထားပြီး Helm values ကနေ Secret name ကို reference လုပ်ပါ။ Private key ကို plaintext Git ထဲ မသိမ်းဘဲ မိမိအသုံးပြုတဲ့ secret-management စနစ်နဲ့ စီမံသင့်ပါတယ်။

Runner group မှာ သုံးခွင့်ပေးမယ့် repositories တွေကို ရွေးထားဖို့လည်း လိုပါတယ်။ Workflow access ကိုပါ ကန့်သတ်ထားရင် သုံးမယ့် workflow နဲ့ ref တွေကို ခွင့်ပြုထားရပါမယ်။ ARC က GitHub မှာ register ဖြစ်နေရုံနဲ့ repository တိုင်းက သုံးနိုင်တာ မဟုတ်ပါဘူး။

ARC runner scale set ကို configure လုပ်ခြင်း#

အောက်က Helm values ဥပမာမှာ GitHub routing၊ runner အရေအတွက်နဲ့ CI node placement ကို သတ်မှတ်ထားပါတယ်။ Docker builds အတွက် chart ရဲ့ Docker-in-Docker mode ကို ရွေးထားပါတယ်။

githubConfigUrl: "https://github.com/acme-corp"
githubConfigSecret: demo-staging-runner-github-app
runnerGroup: demo-staging
runnerScaleSetName: demo-staging-runner

controllerServiceAccount:
  name: gha-runner-scale-set-controller
  namespace: actions-runner-controller

minRunners: 0
maxRunners: 1

containerMode:
  type: dind

template:
  spec:
    automountServiceAccountToken: false
    nodeSelector:
      karpenter.sh/nodepool: ci-runner-amd64
      kubernetes.io/arch: amd64
    tolerations:
      - key: ci-runner
        operator: Equal
        value: "true"
        effect: NoSchedule

githubConfigSecret နဲ့ controllerServiceAccount က တကယ်ရှိတဲ့ Secret နဲ့ controller ServiceAccount ကို ညွှန်းရပါမယ်။ ARC controller နဲ့ runner pods တွေကို namespace သီးခြားစီမှာ ထားနိုင်ပါတယ်။

minRunners: 0 က idle runner မထားဖို့ သတ်မှတ်တာဖြစ်ပြီး၊ maxRunners: 1 က ဒီ scale set ရဲ့ အများဆုံး runner အရေအတွက် ဖြစ်ပါတယ်။ Idle runner တစ်ခု အမြဲထားချင်ရင် minRunners ကို တိုးနိုင်ပါတယ်။ Job မရှိချိန်မှာတောင် pod ရှိနေမှာဖြစ်လို့ node တစ်ခုကို ဆက်ဖွင့်ထားရနိုင်ပါတယ်။

containerMode.type: dind ကို သုံးတဲ့အခါ chart က Docker အတွက် လိုအပ်တဲ့ pod configuration ကို ထည့်ပေးပါတယ်။ ဒီ values ဥပမာမှာ container တစ်ခုချင်းစီရဲ့ resource requests နဲ့ limits ကို မသတ်မှတ်ရသေးပါဘူး။ Custom runner image သို့မဟုတ် Docker resources တွေ ချိန်ညှိမယ်ဆိုရင် သုံးနေတဲ့ chart version ရဲ့ values နဲ့ render ထွက်လာတဲ့ pod template ကို ကြည့်ပြီး ပြင်ရပါမယ်။ ARC 0.15.1 chart values

Workflow က ဘယ်လို ရွေးသုံးမလဲ#

Runner group နဲ့ scale-set name ကို runs-on မှာ ချိတ်ဆက်နိုင်ပါတယ်။ အောက်ပါ job က runner placement နဲ့ Docker အလုပ်လုပ်ကြောင်း စမ်းသပ်ဖို့ ရိုးရှင်းတဲ့ ဥပမာ ဖြစ်ပါတယ်။

name: ARC runner smoke test

on:
  workflow_dispatch:

permissions:
  contents: read

jobs:
  smoke:
    runs-on:
      group: demo-staging
      labels: demo-staging-runner
    steps:
      - name: Check runner
        run: |
          uname -m
          docker info

ဒီ workflow ကို runner group က ခွင့်ပြုထားတဲ့ repository ထဲမှာ ထားရပါမယ်။ Group က access ကို ထိန်းချုပ်ပြီး scale-set label က ဘယ် runner pool ကို သုံးမလဲဆိုတာ ရွေးပေးပါတယ်။

Runner နဲ့ Docker အတွက် resources ခွဲတွက်ခြင်း#

Docker build တစ်ခုမှာ runner process နဲ့ Docker daemon က သီးခြား containers အဖြစ် run နိုင်ပါတယ်။ Workflow steps ကို execute လုပ်တဲ့ runner ရဲ့ memory နဲ့ Docker build သုံးတဲ့ memory ကို ခွဲပြီး စဉ်းစားဖို့ လိုပါတယ်။

အောက်ပါ table က resource sizing ကို စတင်စဉ်းစားဖို့ နမူနာဖြစ်ပါတယ်။ အပေါ်က Helm values ထဲမှာ ဒီ values တွေ အလိုအလျောက် ပါပြီးသား မဟုတ်ပါဘူး။

ComponentCPU requestMemory requestMemory limit
ARC controller100m128Mi512Mi
ARC listener100m128Mi512Mi
Runner container250m512Mi1Gi
Docker sidecar750m1536Mi2Gi

Runner နဲ့ Docker requests ပေါင်းက 1 vCPU နဲ့ 2 GiB ဖြစ်ပါတယ်။ ဒါပေမယ့် 2-vCPU၊ 4-GiB instance တစ်ခုရဲ့ memory အားလုံးကို runner pod က သုံးလို့ မရပါဘူး။ Kubelet၊ networking နဲ့ node agents တွေအတွက်လည်း resources လိုပါတယ်။ Karpenter က node ရွေးတဲ့အခါ အဲဒီ overhead နဲ့ pod ရဲ့ လိုအပ်ချက်တွေကို ထည့်တွက်ရပါတယ်။

Requests က scheduling အတွက်ဖြစ်ပြီး limits က runtime အသုံးပြုနိုင်မှုကို ကန့်သတ်ပါတယ်။ Requests နည်းလွန်းရင် node ပေါ်မှာ workload များလွန်းသွားနိုင်ပြီး၊ limits နည်းလွန်းရင် build အတွင်း OOM ဖြစ်နိုင်ပါတယ်။ Memory တိုးမယ်ဆိုရင် runner က သုံးတာလား၊ Docker က သုံးတာလားဆိုတာ ခွဲတိုင်းတာပြီး သက်ဆိုင်ရာ container ကို ပြင်သင့်ပါတယ်။

DinD ကို custom configuration နဲ့ အသုံးပြုတဲ့အခါ Docker daemon အဆင်သင့်ဖြစ်မှ runner စတင်ဖို့ startup checks နဲ့ shared socket ကို မှန်ကန်စွာ ချိတ်ဆက်ထားရပါမယ်။ Native sidecar သုံးတဲ့ Kubernetes versions တွေမှာ Docker က restartable init container အဖြစ် ရှိနိုင်တာကြောင့် resource settings ပြင်တဲ့အခါ rendered pod ရဲ့ containers နဲ့ initContainers နှစ်ခုစလုံးကို ကြည့်ပါ။

DinD ရဲ့ security tradeoff#

DinD က Docker အခြေခံ workflows တွေနဲ့ ကိုက်ညီရလွယ်ပေမယ့် privileged container အသုံးပြုရတာကြောင့် မယုံကြည်ရတဲ့ job code အတွက် အန္တရာယ်ပိုများပါတယ်။ Taint နဲ့ node selector က scheduling ကို ခွဲပေးနိုင်ပေမယ့် လုံခြုံရေးအတွက် သီးခြား cluster ခွဲထားသလို ကာကွယ်ပေးတာ မဟုတ်ပါဘူး။

Runner group access ကို ကန့်သတ်ပြီး untrusted pull requests တွေကို ဘယ်လို run မလဲဆိုတာ သတ်မှတ်ထားသင့်ပါတယ်။ AWS ကို အသုံးပြုမယ့် jobs တွေမှာ node IAM role ကို မျှသုံးမယ့်အစား workflow OIDC နဲ့ job အလိုက် permissions ပေးပါ။ Trust levels မတူတဲ့ workloads တွေအတွက်တော့ သီးခြား runner groups၊ nodes သို့မဟုတ် CI cluster ခွဲထားဖို့ စဉ်းစားနိုင်ပါတယ်။

Installation ကို အစဉ်လိုက် လုပ်ခြင်း#

အဆင့်တစ်ခုချင်းစီမှာ နောက်အဆင့်အတွက် လိုအပ်တဲ့ dependency အဆင်သင့်ဖြစ်ကြောင်း စစ်ဆေးသွားရင် setup ကို နားလည်ရလွယ်ပါတယ်။

  1. AWS prerequisites — Controller နဲ့ node IAM roles၊ node authorization၊ networking နဲ့ interruption queue ကို ပြင်ဆင်ပါ။
  2. Karpenter CRDs — အသုံးပြုမယ့် controller version နဲ့ ကိုက်ညီတဲ့ CRDs ကို install လုပ်ပါ။
  3. Karpenter controller — အမြဲရှိနေမယ့် managed nodes ပေါ်မှာ run စေပြီး AWS identity နဲ့ queue ကို ချိတ်ပါ။
  4. EC2NodeClass နဲ့ NodePool — Manifests တွေကို apply လုပ်ပြီး resources နှစ်ခုလုံး Ready ဖြစ်ကြောင်း စစ်ဆေးပါ။
  5. ARC controller — Controller နဲ့ CRDs ကို install လုပ်ပါ။
  6. GitHub App Secret — Runner namespace ထဲမှာ credentials ပြင်ဆင်ပါ။
  7. Runner scale set — Helm values နဲ့ install လုပ်ပြီး listener အလုပ်လုပ်ကြောင်းနဲ့ GitHub registration ကို စစ်ဆေးပါ။
  8. Test workflow — Job တစ်ခု run ပြီး runner pod ကနေ EC2 node အထိ lifecycle ကို လိုက်ကြည့်ပါ။

NodePool နဲ့ EC2NodeClass ကို plain manifests၊ Helm သို့မဟုတ် GitOps နဲ့ စီမံနိုင်ပါတယ်။ ဘယ်နည်းကို သုံးသုံး resource တစ်ခုကို စီမံတဲ့ owner တစ်ခုတည်း ရှိသင့်ပြီး installation order ကိုလည်း ထိန်းထားရပါမယ်။

အားသာချက်တွေနဲ့ လက်ခံရမယ့် tradeoffs#

ARC နဲ့ Karpenter ကို တွဲသုံးရတဲ့ အဓိက အားသာချက်က job demand နဲ့ compute capacity ကို ဆက်စပ်ပြီး လိုအပ်သလောက် အသုံးပြုနိုင်ခြင်း ဖြစ်ပါတယ်။ ဒါပေမယ့် automation ပိုများလာတာနဲ့အမျှ ထိန်းသိမ်းရမယ့် components တွေလည်း ပိုများလာပါတယ်။

အချက်ရနိုင်တဲ့အကျိုးလက်ခံရမယ့် tradeoff
Idle capacityအလုပ်မရှိချိန် CI nodes ကို zero အထိ လျှော့နိုင်ခြင်းပထမ job အတွက် node စတင်ချိန် စောင့်ရခြင်း
Ephemeral runnersJob တစ်ခုပြီးတိုင်း runner environment အသစ်ရခြင်းNode ဖယ်ရှားတဲ့အခါ local build cache ပျောက်ခြင်း
Capacity flexibilityWorkload နဲ့ ကိုက်ညီတဲ့ instance types ရွေးနိုင်ခြင်းRequests နဲ့ instance constraints ကို မှန်ကန်စွာ သတ်မှတ်ရခြင်း
Private network accessEKS ကနေ လိုအပ်တဲ့ private services တွေကို ချိတ်ဆက်နိုင်ခြင်းWorkflow code က ရောက်နိုင်တဲ့ network ကို ထိန်းချုပ်ရခြင်း
GitHub access controlRunner groups နဲ့ repositories ခွဲပေးနိုင်ခြင်းApp permissions နဲ့ group policies ထိန်းသိမ်းရခြင်း
CI platform ownershipRunner images နဲ့ capacity policy ကို ကိုယ်တိုင် ထိန်းနိုင်ခြင်းControllers၊ CRDs၊ AMIs နဲ့ monitoring ကို တာဝန်ယူရခြင်း

စရိတ်သက်သာမှုနဲ့ cold start#

Job မရှိချိန်မှာ runner nodes မဖွင့်ထားရတာက idle compute cost ကို လျှော့ပေးနိုင်ပါတယ်။ ဒါပေမယ့် EKS cluster fee၊ controller nodes၊ EBS နဲ့ networking စရိတ်တွေက ရှိနေဆဲပါ။ သက်သာမှုကို EC2 တစ်နာရီဈေးတစ်ခုတည်းနဲ့ မတွက်ဘဲ အောင်မြင်တဲ့ job တစ်ခုအတွက် စုစုပေါင်းကုန်ကျစရိတ်နဲ့ နှိုင်းယှဉ်သင့်ပါတယ်။

Cold start မှာ EC2 provision လုပ်ချိန်၊ node bootstrap၊ image pulls နဲ့ runner initialization တို့ ပါဝင်နိုင်ပါတယ်။ ဒီအဆင့်တချို့က တစ်ပြိုင်တည်း ဖြစ်နိုင်လို့ အဆင့်တိုင်းကို ပေါင်းတွက်တာထက် job နဲ့ node timestamps တွေကနေ တကယ့်စောင့်ချိန်ကို တိုင်းတာပါ။

Job တစ်ခုချင်းက မကြာခဏ ဝင်လာရင် idle runner တစ်ခုထားတာ သို့မဟုတ် consolidation delay တိုးတာက ပိုသင့်တော်နိုင်ပါတယ်။ Jobs တွေကြား အချိန်အကြာကြီး ခြားနေရင်တော့ scale to zero က ပိုအသုံးဝင်ပါတယ်။

ဘာတွေကို စောင့်ကြည့်သင့်သလဲ#

Controller pod က Running ဖြစ်နေရုံနဲ့ CI jobs တွေ အောင်မြင်စွာ run နိုင်တယ်လို့ မသတ်မှတ်နိုင်ပါဘူး။ GitHub demand ကနေ node cleanup အထိ မြင်နိုင်ဖို့ လိုပါတယ်။ ARC နဲ့ Karpenter metrics endpoints တွေကို enable လုပ်ပြီး အသုံးပြုနေတဲ့ monitoring စနစ်နဲ့ collect လုပ်နိုင်ပါတယ်။

စောင့်ကြည့်မယ့်အပိုင်းအသုံးဝင်တဲ့ signals
Controllers နဲ့ listenerAvailability၊ restarts နဲ့ metrics collection health
Runner demandDesired၊ registered၊ busy နဲ့ maximum runners
Job startupQueue wait၊ runner startup နဲ့ job assignment ကြာချိန်
Scheduling နဲ့ provisioningPending pods၊ NodeClaim conditions နဲ့ node readiness
Build resourcesRunner/Docker memory၊ OOMs နဲ့ node disk usage
Scale-downJob ပြီးနောက် runner cleanup နဲ့ empty-node consolidation

Pending runners ကြာနေခြင်း၊ listener မရှိခြင်း၊ node ဖန်တီးမရခြင်း၊ OOM နဲ့ DiskPressure တို့အတွက် alerts သတ်မှတ်နိုင်ပါတယ်။ Thresholds တွေကို ကိုယ့် jobs ရဲ့ ပုံမှန်ကြာချိန်နဲ့ workload ပမာဏအပေါ် အခြေခံပြီး ချိန်ညှိသင့်ပါတယ်။

Startup-duration metrics က စတင်နိုင်ခဲ့တဲ့ jobs တွေကိုပဲ တိုင်းတာနိုင်တာကြောင့် လုံးဝ မစတင်နိုင်တဲ့ job ရဲ့ queue wait ကို သိချင်ရင် GitHub workflow data ကိုပါ ကြည့်ဖို့ လိုပါတယ်။ Job မရှိလို့ runner အရေအတွက် zero ဖြစ်နေတာနဲ့ metrics လုံးဝမရတာကိုလည်း ခွဲခြားထားရပါမယ်။

Workload ကြီးလာတဲ့အခါ ဘာတွေ ပြင်နိုင်သလဲ#

ပထမဆုံး job အောင်မြင်သွားပြီးနောက် ပြင်ဆင်မှုတစ်ခုချင်းစီရဲ့ အကျိုးသက်ရောက်မှုကို တိုင်းတာပြီး capacity တိုးသင့်ပါတယ်။

ပြင်နိုင်တဲ့ settingရနိုင်တဲ့အကျိုးပြန်စစ်ရမယ့်အချက်
maxRunners တိုးခြင်းJobs တွေ ပိုပြီး တစ်ပြိုင်တည်း run နိုင်ခြင်းNodePool limits နဲ့ စမ်းသပ်မယ့် services တွေရဲ့ capacity
minRunners တိုးခြင်းJob စတင်ချိန် ပိုမြန်ခြင်းIdle pods နဲ့ nodes အတွက် စရိတ်
Instance types တိုးထည့်ခြင်းNode ဖန်တီးဖို့ ရွေးချယ်စရာ ပိုများခြင်းArchitecture၊ performance နဲ့ per-node resource fit
Runner/Docker resources တိုးခြင်းBuild ကြီးတွေ run နိုင်ခြင်းဘယ် container က resource လိုတာလဲ၊ node တစ်ခုထဲ ဆံ့သလား
consolidateAfter တိုးခြင်းနီးကပ်တဲ့ jobs တွေကြား node ပြန်သုံးနိုင်ခြင်းIdle node-hours နဲ့ cold-start လျော့ကျမှု
Spot pool ထည့်ခြင်းCompute cost လျှော့နိုင်ခြင်းJob interruption နဲ့ retry လုပ်နိုင်မှု

Runner တစ်ခုက node တစ်ခုထဲမှာ ဆံ့ရမယ့် resource ပမာဏနဲ့ pool တစ်ခုလုံးရဲ့ capacity က သီးခြားကန့်သတ်ချက်တွေ ဖြစ်ပါတယ်။ ဥပမာ pod တစ်ခုက 10 GiB memory လိုတယ်ဆိုရင် 8-GiB instance တွေပဲ ခွင့်ပြုထားတဲ့ pool ရဲ့ စုစုပေါင်း memory limit ကို တိုးပေးရုံနဲ့ schedule လုပ်နိုင်မှာ မဟုတ်ပါဘူး။

ဆက်လက်တိုးချဲ့နိုင်မယ့် နည်းလမ်းများ#

Workload အလိုက် pools ခွဲခြင်း။ Tests သေးသေးတွေ၊ Docker builds ကြီးတွေ၊ ARM jobs တွေအတွက် scale sets နဲ့ NodePools သီးခြားထားနိုင်ပါတယ်။ Access policy တူရင် runner group တစ်ခုတည်းကို မျှသုံးနိုင်ပြီး၊ trust level မတူရင် groups နဲ့ execution environment ကိုပါ ခွဲသင့်ပါတယ်။

Spot ကို သီးခြားစမ်းသပ်ခြင်း။ Retry လုပ်လို့ရတဲ့ tests နဲ့ builds တွေကို Spot pool ပေါ်တင်နိုင်ပါတယ်။ Interruption ဖြစ်တဲ့ job ကို workflow က ဘယ်လို ကိုင်တွယ်မလဲဆိုတာ စမ်းသပ်ပြီးမှ အသုံးပြုမှုကို တိုးသင့်ပါတယ်။

Ephemeral nodes နဲ့ ကိုက်ညီတဲ့ build cache။ Node ဖယ်ရှားတဲ့အခါ local cache ပျောက်သွားတာကြောင့် build တိုင်း အစကနေ ပြန်လုပ်ရရင် startup အပြင် build time ပါ ကြာနိုင်ပါတယ်။ လိုအပ်တဲ့ workflows တွေအတွက် node အပြင်ဘက်မှာ cache ထားနိုင်မယ့်နည်းကို ရွေးပြီး cache hit rate နဲ့ build time ကို တိုင်းတာနိုင်ပါတယ်။

Updates ကို ပုံမှန်စီမံခြင်း။ ARC chart၊ Karpenter controller၊ CRDs၊ AMI နဲ့ runner image ကို compatible versions အဖြစ် ထိန်းထားဖို့ လိုပါတယ်။ Upgrade တစ်ခုချင်းစီကို test workflow နဲ့ စစ်ပြီး runner creation၊ job execution နဲ့ node cleanup တို့ ဆက်အလုပ်လုပ်ကြောင်း အတည်ပြုသင့်ပါတယ်။

Job တစ်ခုကနေ lifecycle တစ်ခုလုံး စစ်ဆေးခြင်း#

Setup အောင်မြင်ကြောင်း သိဖို့ job တစ်ခုကို CI pool အလွတ်ကနေ စတင်ပြီး ပြန်လည် idle ဖြစ်သွားတဲ့အထိ ကြည့်နိုင်ပါတယ်။

  1. Controllers၊ listener နဲ့ GitHub registration အဆင်သင့်ဖြစ်ပြီး NodePool နဲ့ EC2NodeClass က Ready ဖြစ်ကြောင်း စစ်ဆေးပါ။
  2. Test workflow ကို run ပြီး runner pod ဖန်တီးလာတာကို ကြည့်ပါ။
  3. Node အသစ်လိုရင် NodeClaim ကနေ EC2 instance၊ EKS node Ready ဖြစ်လာတဲ့အထိ ကြည့်ပါ။
  4. Job က သတ်မှတ်ထားတဲ့ scale set နဲ့ CI node ပေါ်မှာ အောင်မြင်ကြောင်း စစ်ဆေးပါ။ Docker builds သုံးမယ်ဆိုရင် image သေးသေးတစ်ခု build လုပ်ပြီးပါ စမ်းသပ်ပါ။
  5. Job ပြီးတဲ့အခါ runner pod ကို ဖယ်ရှားပြီး empty CI node ကို consolidation လုပ်သွားကြောင်း စစ်ဆေးပါ။
  6. Monitoring က job ရှိချိန်နဲ့ idle ဖြစ်နေချိန် နှစ်မျိုးလုံးကို မှန်ကန်စွာ ပြသနိုင်ကြောင်း စစ်ဆေးပါ။

consolidateAfter: 5m ဆိုတာ ငါးမိနစ်တိတိမှာ instance ပျောက်သွားမယ်လို့ မဆိုလိုပါဘူး။ Node က consolidation လုပ်လို့ရတဲ့ အခြေအနေရှိရမယ်၊ သက်ဆိုင်ရာ checks နဲ့ termination အတွက်လည်း အချိန်လိုပါတယ်။ Node ပေါ်က DaemonSets တွေရဲ့ requests က capacity တွက်ရာမှာ ပါဝင်ပေမယ့် အဲဒီ pods တွေရှိနေတာကိုပဲ ကြည့်ပြီး CI job ရှိနေသေးတယ်လို့ မယူဆသင့်ပါဘူး။

ARC နဲ့ Karpenter ကို EKS ပေါ်မှာ တွဲသုံးတာက demand မတည်ငြိမ်တဲ့ CI workloads တွေအတွက် သင့်တော်တဲ့ ရွေးချယ်မှုတစ်ခု ဖြစ်နိုင်ပါတယ်။ Runner နဲ့ node scaling ကို သီးခြားနားလည်ပြီး access၊ resource sizing နဲ့ lifecycle ကို စနစ်တကျ သတ်မှတ်ထားတဲ့အခါ workload နဲ့ လိုက်လျောညီထွေ တိုးချဲ့နိုင်တဲ့ CI platform တစ်ခု ရနိုင်ပါတယ်။ Jobs နည်းပြီး စတင်ချိန်မြန်ဖို့ ပိုအရေးကြီးတဲ့ workload မျိုးမှာတော့ controllers နဲ့ nodes တွေကို ကိုယ်တိုင်ထိန်းရတဲ့ overhead က တကယ်တန်ဖိုးရှိသလားဆိုတာပါ ထည့်တွက်သင့်ပါတယ်။

Found this helpful?

Share this post

Comments