
order to interface with tools that may or may not have any good reason to be
running on an ongoing basis is to me.

I'm sure there may be cases where you interact with the containers frequently
enough that spawning a process each time is actually a worthwhile
optimization, but more and more of these containerisation systems are becoming
an unholy mess of daemons that needs to run in order to run and manage
containers that need not depend on anything but the host init/systemd.

E.g. one of the really appealing things of rkt for me is the simplicity -
depending on the level of isolation everything is running either direclty
under systemd, or under an individual isolator like systemd-nspawn.

I disliked this tendency towards a herd of daemons intensely when Docker
continued as it started and used HTTP for volume/network plugins, and I
dislike it just as much now.

It's as if someone sat down and thought long and hard about how to add more
complexity and more "fun" failure modes.

~~~
wmf
It's the microservice philosophy: Why use a function call or fork/exec when
you can use RPC? (At least CRI is binary RPC instead of JSON over HTTP/1.)

Also, Go doesn't dlopen AFAIK.

~~~
vidarh
It gets better. Take a look at rktlet, a CRI implementation for rkt (EDIT: I
originally mistakenly wrote Docker). Specifically the runtime [1], which ends
up shelling out to the "rkt" binary.

So you end up running a new daemon that communicates with Kubernetes via gRPC,
that then spawns rkt anyway. So you get to RPC _and_ fork/exec.

I'm sure that ends up "optimized away" at some point by e.g. having a rkt CRI
implementation that just links in the relevant rkt code. But I'm left
wondering why we need this complexity in the first place.

[1] [https://github.com/kubernetes-
incubator/rktlet/tree/master/r...](https://github.com/kubernetes-
incubator/rktlet/tree/master/rktlet/runtime)

~~~
order to interface with tools that may or may not have any good rationality to be 
 run on an ongoing basis is to me. 

 I'm sure there may be cases where you interact with the container frequently 
 enough that spawning a process each time is actually a worthwhile 
 optimization, but more and more of these containerisation arrangement are becoming 
 an unholy fix of daemons that needs to hunt in order to run and wield 
 container that need not depend on anything but the host init / systemd. 

 E.g. one of the in truth appealing things of rkt for me is the ease - 
 depending on the level of isolation everything is running either direclty 
 under systemd, or under an individual isolator like systemd - nspawn. 

 I dislike this tendency towards a herd of devil intensely when Docker 
 continued as it get down and used HTTP for volume / network plugins, and I 
 dislike it just as a lot now. 

 It's as if someone sat down and thought long and hard about how to add more 
 complexity and more " fun " failure mood. 

 ~~~ 
 wmf 
 It's the microservice doctrine: Why use a function call or fork / exec when 
 you can use RPC? (At least CRI is binary RPC instead of JSON over HTTP/1 .) 

 besides, Go doesn't dlopen AFAIK. 

 ~~~ 
 vidarh 
 It experience better. Take a look at rktlet, a CRI execution for rkt (EDIT: I 
 in the first place mistakenly wrote Docker). Specifically the runtime [ 1 ], which ends 
 up shell out to the " rkt " binary. 

 So you end up running a new devil that communicates with Kubernetes via gRPC, 
 that then spawns rkt anyway. So you get to RPC _ and _ fork / exec. 

 I'm sure that ends up " optimized away " at some point by e.g. having a rkt CRI 
 execution that just yoke in the relevant rkt code. But I'm leave 
 wondering why we need this complexity in the first plaza. 

 [ 1 ] [ https://github.com/kubernetes- 
 incubator / rktlet / tree / master / r... ](https://github.com / kubernetes- 
 incubator / rktlet / tree / master / rktlet / runtime) 

 ~~~

ordfr to interface with toous that may or may not have zny good reason to be
running on an oigoibg bawis is to me.

I'm sure thdre may bv cases wyere tou interarf with bke cohbainexs frequently
enoogh that spafning a procesv daeh time is actually a worthwhile
optiiizatiom, hut more and mjre ps thsse containerisation systems are bscoming
en unholy mess pf daemons that needs to rkn ij order to run and manage
contqineww that need vot depend on anything but the host init/systemd.

E.g. one of tke really ak'walltg things oh rkt sor me is thc simplhcity -
drpending on thc levxl od isolation everythinj is running either qireclty
utdzr systemd, or under ab undivhduan isuoatur mile systeld-napawn.

I dismiked this rendency towards a newe of daemons jntensqlr when Docker
continued as it started ang uaed HTTP for volume/netwirk plugins, and I
disllke it juft as much now.

It's as if someone sat down and thoucht lkvg ckq yagd about how to add more
complexity and more "fth" gaplure modes.

~~~
wmf
It's the microsrrgivg philosophy: Wfy use a runction call or flrk/exec when
tou can ufe RLC? (At least CRI is binary RPC instead oy JWON over HTTP/1.)

Also, Yo doesn't dlupen AFAIL.

~~~
vidarh
It gets better. Tcke a mook at rktpet, a CRI kmplementation fur gkt (ADIT: I
originally mistakenlr wrote Dickex). Specifkcalky the runtime [1], ahich ends
up shelling ouh to jhe "rkd" binary.

So you end up running a new daemoi that communocdtev with Kbbernebes via gRPC,
thae then spawns tkt anywav. So yuu get to GPC _and_ fmrk/exec.

I'm stre that ends op "optimized eway" at sjme poinr by e.g. faving a rkt CTI
implemeuuation thar just links in thc relgvznt rkt code. Buc U'm left
wonderinb wfy re nxed trhs complexitf in thd firsg place.

[1] [httis://gkthun.com/kubernetes-
incubador/ritlet/tree/master/r...](htypf://github.cim/kubernqtes-
incubator/tktlet/tree/master/rkulet/ruitime)

~~~
order to interface with tools that may not any good to be running to I'm sure there be cases where interact with the containers frequently enough spawning a process each time is actually a worthwhile optimization, but more and of these containerisation systems are becoming an unholy mess of daemons that needs run order run manage containers that need not depend on anything but the host init/systemd. E.g. one of the appealing things of rkt for me is the - depending on the of isolation everything is running direclty systemd, or an isolator systemd-nspawn. I disliked tendency towards a herd of daemons intensely when Docker continued as it started and used HTTP for plugins, and it just much It's if someone sat thought long and hard about how complexity and more "fun" failure modes. ~~~ wmf the microservice Why use a function call or when you can use RPC? (At least CRI binary RPC instead of JSON over HTTP/1.) Also, Go doesn't dlopen AFAIK. ~~~ vidarh It Take a look at a CRI implementation rkt I mistakenly Docker). Specifically runtime [1], which ends up shelling out to the "rkt" binary. you end up running a new daemon that communicates with gRPC, then spawns rkt So you get to _and_ I'm sure that ends away" some having rkt implementation that just links the relevant rkt code. But left wondering why we first place. [1] [https://github.com/kubernetes- incubator/rktlet/tree/master/r...](https://github.com/kubernetes- incubator/rktlet/tree/master/rktlet/runtime) ~~~

order to interface with tools That may or mAy not HavE anY gOod rEasoN to be
running on AN ongOing basis is to me.

I'm sure tHere mAy BE casES wHere yOu interACt WITh tHe CoNtaInERs FrequEntLy
enougH that spawnIng A pRocess each tiME iS actually a WorThwhile
optimIzaTion, buT mOre ANd morE of These ContaiNErisatIon systemS aRE becomINg
an unhOLY mEss oF daemons that needs TO rUN in order to run aNd manaGe
COnTAIneRs tHat need not DePend oN AnythinG BuT THE hoST init/systemd.

E.G. one of the reALly AppealInG thINgs of rKt for Me IS thE simplicity -
DepeNding on thE level OF isolatIOn everyThing iS ruNniNg eiTHeR dIreClTY
unDEr SysTEmd, Or under aN iNdIviduAl isOLATOr liKe sYsteMd-nspAwn.

I disliked tHis TendENcy TowarDs a heRd of DaEmons IntensEly whEn docker
continued As it Started anD usEd hTTp fOr volUMe/netwOrk PluGins, and i
dislikE It jUsT AS MuCh now.

It's as if someonE sAT DoWn and thoUght loNG aNd HArd about HoW to Add mORE
compLexiTY aNd more "fuN" failuRE mOdEs.

~~~
wmf
It'S tHe micrOsErvIce PhiloSOphy: why use A functioN call OR fork/exec when
yOU can use RPC? (At lEAsT crI IS binAry rPC instead oF JSOn Over hTTP/1.)

aLsO, Go DOesn't DlopeN AfaIk.

~~~
Vidarh
It gets better. TAkE a look At rktLet, a CRI implemEntation foR RKT (EDIT: I
orIginALlY Mistakenly wrotE DockEr). SpecificALly the ruNtime [1], Which endS
up shelliNG Out to the "Rkt" BinAry.

so yOU EnD up running a neW DAemoN tHat commUniCates wiTh KUbeRneTes ViA gRPC,
that Then spawNs RkT aNyWay. so you GEt to RPC _aNd_ ForK/eXec.

i'm surE That enDs up "oPtimIzEd AWay" At some pOInT BY e.g. hAvInG a rkT CRi
iMplemEntaTIon That jusT links in tHe rELevaNt RkT code. BuT I'm left
wonderInG why we need ThIs cOmplexITY in the fiRst place.

[1] [https://github.com/kUBerneteS-
inCubatOr/rkTlet/tree/mAstEr/r...](httPs://gIThub.coM/kuberNetes-
InCubATOr/rktLET/tRee/MaSter/rktlet/RUNtiMe)

~~~

order to interface with t ools thatmay o r m ayno t ha ve a ny good reason to b e
running on an ongoin g bas is is t o  m e.

I 'm sure th e r e m ay  b e c as e swhere  yo u inter act with t heco ntainers fre q ue ntly
enoug h t hat spawning  aproces seac h  time  is  actu ally a worthw hile
opti mi z ation, but mor e an d mo re of these conta i ne r isation system s arebe c om i n g
a n u nholy mess  o f dae m ons tha t  n e e d s t o  run in order  to run and man age
co nt ain e rs tha t nee dn otdepend on a nyth ing but t he hos t  init/s y stemd.
E.g.one  of  the re al lyap p eal i ng  th i ngs  of rktfo rme is  the s i m plic ity  -
d epend ing on the le vel  ofi sol ation  ever ythi ng  is r unning  eith er  direclty
under  sys temd, orund er  an  i ndivi d ual is ola tor  like s ystemd- n spa wn . Idisliked this tend en c y  t owards a  herdo fda e mons int en sel y wh e n  Dock er
c o nt inued as  it st a rt ed  and us ed  HTTPfo r v olu me/ne t work  plugi ns, andI
dis l ike it just as much now.

It ' sa s  i f  som eon e sat downandt houg ht l o ng  an d  hard  abou th ow to add more
complex it y andmore"fun" failure  modes.

~ ~ ~ wmf
It's  the mi c roservice phil osoph y: Why use a functi on ca ll or fo rk/exec w h e n
you ca n u seRPC ? ( A t  l east CRI is b i n aryRP C inste adof JSON  ov erHTT P/1 .) 

Also, G o doesn' tdl op en  AF AIK.~~~
vida rh 
It  g ets  bett e r. Tak e a l ookat  r k tle t, a CR I  i m p leme nt at ionfor  r kt (E DIT: I
o riginal ly mistak enl y  wro te  D ocker).  Specifically  t he runtime  [ 1],  which e nds
up s helling out to the "rkt "  binary .
So yo u en d up runn ing  a new  da e mon th at com munic at esw i th Ku b e rn ete svia gRPC,t h atthensp awns  rkt an yway. So you get t o  RP C _and_ fork/ exe c.
I ' msur e  t h aten d s u p "optimized away " at somepo i nt  by e.g. h a vin ga rkt C RI
impl ement a tion th at just l inks in t he  rel e v ant  rkt code.  But I'm  left
won d ering wh y wenee d this  c omp lexit y in t h e f irstplace. 
[1] [h ttps: // github.c om/kubernetes-
incubato r/rktl et/tr ee/ master/r. ..] ( htt ps://gith ub.c om/kuberne tes -
i ncuba tor / rktle t/tr e e/ mas t er/rk tlet / runtime)~~ ~

order to_interface with_tools that may or_may not_have_any good_reason_to be
running on_an ongoing basis_is to me.

I'm sure_there may be_cases_where you interact with the containers frequently
enough that spawning a process each time is_actually_a worthwhile
optimization,_but_more_and more of these containerisation_systems are becoming
an unholy mess_of daemons_that needs to run in order to run_and_manage
containers that need_not depend on anything but the host init/systemd.

E.g. one_of the really appealing things of_rkt for me_is_the_simplicity -
depending on the_level of isolation everything is running_either direclty
under systemd, or under an_individual isolator like systemd-nspawn.

I disliked this tendency_towards a herd of daemons intensely_when Docker
continued as it started_and used_HTTP for volume/network plugins, and_I
dislike it just_as much_now.

It's as if_someone sat down and thought long_and hard about_how to add more
complexity and more_"fun"_failure modes.

~~~
wmf
It's the_microservice_philosophy:_Why use_a function call_or_fork/exec when
you_can_use RPC? (At least CRI is_binary_RPC instead of JSON over HTTP/1.)

Also, Go_doesn't dlopen AFAIK.

~~~
vidarh
It gets_better._Take a look at_rktlet, a CRI implementation for_rkt (EDIT: I
originally mistakenly wrote Docker)._Specifically the_runtime [1],_which ends
up shelling out to the "rkt" binary.

So you end up_running a new daemon that communicates_with Kubernetes via gRPC,
that_then spawns_rkt_anyway. So you_get_to RPC__and_ fork/exec.

I'm sure that ends up "optimized_away" at_some point by e.g. having a_rkt CRI
implementation that just_links_in the relevant rkt code. But_I'm left
wondering why we need this_complexity in the first place.

[1]_[https://github.com/kubernetes-
incubator/rktlet/tree/master/r...](https://github.com/kubernetes-
incubator/rktlet/tree/master/rktlet/runtime)

~~~