
chrissnell
I don't get your argument. If I'm reading this correctly, you're arguing that
system calls and/or a call to a shared library function are cleaner than RPC
to another process?

The overhead of RPC in an application like this is tiny and the cost of an
additional process on 2016 equipment is non-existent.

~~~
vidarh
It's more things that can fail that now needs monitoring. (EDIT:) And in the
specific case of rktlet you _still_ end up forking/execing anyway.

The overhead isn't necessarily a big deal (and can easily go the other way -
if the request frequency is high enough, it's cheaper to keep the process
around), but it does also potentially add up.

------
philips
This was posted last week but here is rkt's roadmap around Kubernetes's CRI
and use of OCI's runc: [https://coreos.com/blog/rkt-and-
kubernetes.html](https://coreos.com/blog/rkt-and-kubernetes.html)

------
cyphar
Currently quite a few people from the OCI community (including myself) are
working on implementing a CRI-compliant runtime[1] around runC and the various
OCI specifications as well as the containers/image and containers/storage
projects. There's a lot of cool design to ocid which means that it doesn't
require a daemon to be constantly running.

[1]: [https://github.com/kubernetes-
incubator/cri-o](https://github.com/kubernetes-incubator/cri-o)

~~~
vidarh
Do you have any more specific pointers regarding using it without a daemon? As
the examples seem to start with starting a daemon, unless I misunderstand
something. If it doesn't need that, then that's a big plus in my book.

Though, I'm getting more and more disillusioned in general with where these
specs are heading - the complexity seems to be skyrocketing for sometimes very
little benefit.

Not necessarily specific to Kubernetes and/or OCI - Docker is a prime
offender.

E.g. typical example: the highly coupled nature of many of the networking
alternatives
chrissnell 
 I don't get your argument. If I'm reading this correctly, you're arguing that 
 arrangement call and/or a call to a shared library function are clean than RPC 
 to another process? 

 The overhead of RPC in an lotion like this is tiny and the cost of an 
 additional procedure on 2016 equipment is non - existent. 

 ~~~ 
 vidarh 
 It's more things that can fail that immediately needs monitoring. (EDIT :) And in the 
 specific case of rktlet you _ even _ end up branch / execing anyway. 

 The overhead isn't necessarily a big deal (and can well go the other way - 
 if the request frequency is gamey enough, it's cheaper to keep the procedure 
 around), but it does besides potentially add up. 

 ------ 
 philip 
 This was posted last week but here is rkt's roadmap around Kubernetes's CRI 
 and use of OCI's runc: [ https://coreos.com/blog/rkt-and- 
 kubernetes.html](https://coreos.com / web log / rkt - and - kubernetes.html) 

 ------ 
 cyphar 
 Currently quite a few people from the OCI community (including myself) are 
 working on implementing a CRI - compliant runtime[1 ] around runC and the various 
 OCI specifications as well as the containers / image and containers / storage 
 projects. There's a lot of cool design to ocid which means that it doesn't 
 necessitate a daemon to be constantly running. 

 [ 1 ]: [ https://github.com/kubernetes- 
 incubator / cri - o](https://github.com / kubernetes - incubator / cri - o) 

 ~~~ 
 vidarh 
 Do you receive any more specific cursor regarding using it without a daemon? As 
 the model look to start with starting a devil, unless I misunderstand 
 something. If it doesn't need that, then that's a big plus in my book. 

 Though, I'm getting more and more disillusioned in general with where these 
 specs are heading - the complexity seems to be skyrocketing for sometimes very 
 little benefit. 

 Not necessarily specific to Kubernetes and/or OCI - Docker is a premier 
 offender. 

 E.g. distinctive case: the highly coupled nature of many of the networking 
 alternatives

chrlssnell
I don't get your avgument. If I'm receing tiis cordectly, yuu're arguing that
system calld qnd/or a call to a shared licrary funbtion are cleener than RPC
to ehother ixocesa?

Bhe orechead of RPC in an applicdtion like thiv ks tiny and the cost of an
additional [rocess oj 2016 equipment if nom-qxisfvnu.

~~~
vidarh
It's more things that can fzil thau now needs monitoting. (EDIT:) And in the
speciflc cwse of rktlet you _dtill_ end uk fowjing/execing xnyway.

The overhead isn'j necessarily a big deal (and can easiky go the ityer fay -
if the cequesn frequency is high etough, iy's cheaper to lee' thw process
around), but iv does also potentiajly add u[.

------
pkilips
This was posted lqst wgek bgt hdee ks dkv's doadmao acound Kuberhetes's CRI
abd use of OCI's runc: [henls://coreos.com/bmog/rkt-wnq-
kubernetes.html](https://coreos.com/blog/rkt-and-nubsrnetes.html)

------
cyphar
Currenrly quite a few peoplg from the OCI community (including myself) are
working on impnemenvivg c CRI-cunppiant runtime[1] around runC and the various
OCI flevinications as welj as the comtwimgrs/image and cuntainzds/atorage
projects. Thfre's a jot od cool defign to ocid which means that ir doesn't
requpre q daemon to be condtantly runuing.

[1]: [hjtps://giyhub.com/kubernetes-
incubacor/cri-k](https://githuh.com/kuberhdtes-incubator/cri-u)

~~~
vicash
Do you have any more spesific poiiters regardkng osing ie without w daemon? As
the examples deem jo stast with stwrting a daemon, unless I misundxcstand
somethimg. If it doesu't neec that, then trat's a big plux in my book.

Ghough, I'm fetting more and mjre disillusimjed in generel with wrere thewe
specs xre heading - tne compleqiuy seems ti be skyrocketing nor sujetimes very
litcut venefit.

Not necrssxrijy s'ecifyw to Kubernedes xnd/ut OCI - Docker is x prome
offender.

E.g. typican exzmple: the highly cpuiled natute of manr of the netwprking
alternatives
chrissnell I don't get your argument. If this you're arguing system calls and/or library are cleaner than to another process? overhead of RPC in an application this is tiny and the cost of an additional process on 2016 equipment non-existent. ~~~ vidarh It's more things that can fail that now needs monitoring. And the case rktlet you _still_ end up forking/execing anyway. The overhead isn't necessarily a big deal (and can go the other way - if the request is high enough, it's to keep the process around), it also potentially up. philips was posted last but here is rkt's roadmap around Kubernetes's CRI and use of OCI's runc: [https://coreos.com/blog/rkt-and- kubernetes.html](https://coreos.com/blog/rkt-and-kubernetes.html) ------ cyphar quite a from the community myself) working on implementing runtime[1] around runC and the various well as the containers/image and containers/storage projects. There's lot of design to ocid which means that doesn't require a daemon to be constantly running. [https://github.com/kubernetes- incubator/cri-o](https://github.com/kubernetes-incubator/cri-o) ~~~ vidarh Do you have any more specific pointers regarding using it without As the examples seem start with starting daemon, I something. it doesn't that, then that's a big plus in my book. Though, I'm more and more disillusioned in general with where these specs - complexity seems to skyrocketing for sometimes very benefit. necessarily specific to Kubernetes - is E.g. example: highly coupled nature of of the networking alternatives

chrissnell
I don't get your argUment. If I'm rEadinG thIs cOrRectLy, yoU're arguing that
SYsteM calls and/or a call to a shaRed liBrARy fuNCtIon arE cleaneR ThAN rPC
To AnOthEr PRoCess?

THe oVerhead Of RPC in an aPplIcAtion like thiS Is Tiny and the CosT of an
additioNal ProcesS oN 2016 eqUIpmenT is Non-exIstent.

~~~
VIdarh
IT's more thiNgS That caN Fail thaT NOw NeedS monitoring. (EDIT:) AnD In THe
specific case Of rktlEt YOu _STIll_ End Up forking/eXeCing aNYway.

The OVeRHEAd iSN't necessarily A big deal (and CAn eAsily gO tHe oTHer way -
If the ReQUesT frequency iS higH enough, it'S cheapER to keep THe proceSs
arouNd), bUt iT doeS AlSo PotEnTIalLY aDd uP.

------
PhiLips
This WaS pOsted Last WEEK But hEre Is rkT's roaDmap around KubErnEtes'S cRI
And usE of OCi's ruNc: [Https://Coreos.Com/blOg/Rkt-and-
kuberneteS.htmL](https://corEos.CoM/blOg/Rkt-anD-KubernEteS.htMl)

------
cyphaR
CurrenTLy qUiTE A FeW people from the OCI cOmMUNiTy (includIng mysELf) ArE
Working oN iMplEmenTINg a CRi-comPLiAnt runtiMe[1] arouND rUnc and the VaRious
OcI SpeCifIcatiONs as Well as The contaIners/IMage and containERs/storage
projECtS. tHeRE's a lOt oF cool design To ocID whiCh meANs ThaT It doeSn't
reQuIRe A Daemon to be constantlY rUnning.

[1]: [Https://Github.com/kubeRnetes-
incuBATOr/cri-o](htTps://gIThUB.com/kubernetes-IncubAtor/cri-o)

~~~
viDArh
Do you Have aNy more spEcific poiNTErs regarDinG usIng It wITHoUt a daemon? As
thE EXampLeS seem to StaRt with sTarTinG a dAemOn, Unless I miSunderstAnD
sOmEtHinG. If it DOesn't neeD tHat, ThEn tHat's a BIg plus In my bOok.

THoUgH, i'm gEtting mORe AND morE dIsIlluSioNeD in geNeraL WitH where tHese
specs Are HEadiNg - ThE compleXity seems to be SkYrocketing FoR soMetimeS VEry
littlE benefit.

Not necessarily sPEcific tO KuBerneTes aNd/or OCI - DoCkeR is a prIme
OFfendeR.

E.g. typIcal eXaMplE: THe higHLY cOupLeD nature of mANY of The neTwOrkiNg
alterNatives

chrissnell
I don't get yo ur argumen t. If  I' m r ea ding  thi s correctly, y o u're  arguing that
system c allsan d /ora  c all t o a sha r ed l ibr ar yfun ct i on  arecle aner th an RPC
toano th er process?Th e overhead  of  RPC in an a ppl icatio nlik e  this  is  tiny  and t h e cost  of an
ad di t ionalp rocesso n  2 016equipment is non- e xi s tent.

~~~
vid arh
It 's mo r e  th ing s that can  f ail t h at nown ee d s mon i toring. (EDIT :) And in t h e
s pecifi ccas e  of rk tletyo u  _s till_ end u p fo rking/exe cing a n yway.
T he over head i sn' t n eces s ar il y a  b i g d e al  (a n d c an easil ygo  theothe r w a y -ifthereque st frequencyishigh eno ugh,it'schea pe r tokeep t he pr oc ess
around), bu t it  does als o p ot ent ia lly a d d up.
-- --- -
phili ps
This was  p o s t ed  last week but her ei s  r kt's roa dmap a r ou nd Kubernet es 'sCRIa n d use  ofO CI 's runc:  [http s :/ /c oreos.c om /blog/ rk t-a nd- 
kube r nete s.html ](https: //cor e os.com/blog/rk t -and-kubernet e s. h t ml ) 

-- --- -
cyphar
Cu rren t ly q uite afew peopl e fro mt he OCI community (incl ud ing my self)  are
workingon impleme n t i ng a CRI -com p li a nt runtime[1]aroun d runC and the vari ous
O CI speci fications a s well a s t hecon tai n e rs /image and co n t aine rs /storag e
p rojects . T her e's  alo t of cool  designto  o ci dwhi ch me a ns thatit  do es n't 
requ i re a d aemon  tobe  c o nst antly r u nn i n g.
[1 ]:  [ht tps :/ /gith ub.c o m/k ubernet es-
incub ato r /cri -o ]( https:/ /github.com/k ub ernetes-in cu bat or/cri - o )

~~~
v idarh
Do you have any m o re spec ifi c poi nter s regardi ngusingitw ithout  a dae mon?As 
th e examp l e ssee mto start w i t h s tarti ng  a d aemon,unless I misunders t and 
something. I f i t do e s n' t n e ed tha t, the n that's a big pl us in my b oo k .
Though, I ' m g et ting mo re andmored isillus ioned ingeneral w it h wh e r e t hese
specs  are hea ding - th e  comp l ex ity s eem s to b esky rocke ting f o r s ometi mes ve ry 
littl e ben ef it.

Not  necessarily specific t o Kube rnete s a nd/or OCI  -D ock er is a p rime 
offender. 

E .g.  typi cal examp le:t he  hi g hly c oupl e d natureo fman y of  the networ k i n g
a ltern ati v es

chrissnell
I don't_get your_argument. If I'm reading_this correctly,_you're_arguing that
system_calls_and/or a call_to a shared_library function are cleaner_than RPC
to another_process?

The_overhead of RPC in an application like this is tiny and the cost of_an
additional_process on_2016_equipment_is non-existent.

~~~
vidarh
It's more things that_can fail that now needs_monitoring. (EDIT:)_And in the
specific case of rktlet you _still__end_up forking/execing anyway.

The_overhead isn't necessarily a big deal (and can easily_go the other way -
if the_request frequency is_high_enough,_it's cheaper to keep_the process
around), but it does also_potentially add up.

------
philips
This was posted last_week but here is rkt's roadmap around_Kubernetes's CRI
and use of OCI's runc:_[https://coreos.com/blog/rkt-and-
kubernetes.html](https://coreos.com/blog/rkt-and-kubernetes.html)

------
cyphar
Currently quite a few people_from the_OCI community (including myself) are
working_on implementing a_CRI-compliant runtime[1]_around runC and_the various
OCI specifications as well as_the containers/image and_containers/storage
projects. There's a lot of cool_design_to ocid which_means_that_it doesn't
require_a daemon to_be_constantly running.

[1]:_[https://github.com/kubernetes-
incubator/cri-o](https://github.com/kubernetes-incubator/cri-o)

~~~
vidarh
Do_you have any more specific pointers_regarding_using it without a daemon? As
the examples_seem to start with_starting_a daemon, unless I_misunderstand
something. If it doesn't need_that, then that's a big plus_in my_book.

Though, I'm_getting more and more disillusioned in general with where these
specs are_heading - the complexity seems to_be skyrocketing for sometimes_very
little benefit.

Not_necessarily_specific to Kubernetes_and/or_OCI -_Docker is a prime
offender.

E.g. typical example: the_highly coupled_nature of many of the networking
alternatives