 build that passes
locally to also pass on CI. This cuts down on a lot of potential back and
forth. The only shared dependency between CI/local/prod/staging is docker
itself.

Another benefit is (almost) complete isolation. This means rather than having
different vm images tracking different projects, you can have a single vm
image with docker, and have each container running on the vm for any version
of any build across your system. From a CI perspective you can abstract most
of the complex configuration for your applications into "docker build -t
myapp_test./Dockerfile.test && docker run myapp_test".

Containers use a differential filesystem, so N running containers for an
application will take up 1 X the size of the container image + N x the average
space of changes made in the running containers on top of that base image.
This makes larger images highly space efficient without having to worry about
different instances treading on the same folders.

The line between dev and ops blurs a little (devops), but clear
responsibilities. Ops becomes responsible for maintaining the docker
infrastructure, and dev is responsible for everything inside the container
boundary, the container image, installed packages, code compilation, and how
the containers interact. A container mantra is "no more 'well it worked on MY
machine'". If it works for the dev, it really will work in prod.

Besides this, there a number of benefits around speed, accessibility,
debugging, standardization, the list goes on. There are also a ton of great
and varied Docker CI solutions out there, from specific Docker based CI like
us (codeship), Shippable, Drone, Circleci, as well as standard solutions like
jenkins via plugins. Many hosting solutions are supporting docker redeploy
hooks for CI purposes. The standardized nature of containers make it trivial
for vendors to provide integrations. Even if you don't use docker yourselves,
this is certainly a great space to watch.

Technically you can use docker for CI/CD without using it for deploying your
app. When you do this you lose some of the benefits listed, but not all. You
lose the cohesion between CI/local and prod, but you still gain a whole lot in
terms of speed and complexity within your CI infrastructure.

Thomas Shaw did a great talk at
build that passes 
 locally to also pass on CI. This cut down on a fortune of potential back and 
 forth. The alone shared dependency between CI / local / goad / staging is docker 
 itself. 

 Another benefit is (almost) accomplished isolation. This means rather than suffer 
 different vm picture tracking different projects, you can have a single vm 
 image with stevedore, and have each container running on the vm for any version 
 of any build across your organization. From a CI perspective you can abstract most 
 of the complex shape for your applications into " stevedore build -t 
 myapp_test./Dockerfile.test & & docker run myapp_test ". 

 Containers use a differential filesystem, so N running containers for an 
 lotion will take up 1 X the size of the container image + N x the average 
 space of changes made in the run containers on top of that base image. 
 This makes larger images highly space efficient without having to concern about 
 unlike instances treading on the same booklet. 

 The line between dev and ops blurs a little (devops), but clean 
 responsibilities. Ops becomes responsible for maintaining the stevedore 
 infrastructure, and dev is responsible for everything inside the container 
 boundary, the container image, installed packages, code compilation, and how 
 the containers interact. A container mantra is " no more' well it worked on MY 
 machine' ". If it works for the dev, it really will work in prod. 

 Besides this, there a number of benefit around speed, handiness, 
 debugging, standardization, the list goes on. There are also a short ton of great 
 and varied Docker CI solutions out there, from specific Docker free-base CI like 
 us (codeship), Shippable, Drone, Circleci, as well as standard solutions like 
 jenkins via plugins. Many hosting solutions are hold docker redeploy 
 hooks for CI purposes. The standardized nature of containers reach it trivial 
 for seller to provide integrations. Even if you don't use stevedore yourselves, 
 this is certainly a great space to watch. 

 Technically you can use docker for CI / CD without using it for deploying your 
 app. When you do this you lose some of the benefits listed, but not all. You 
 misplace the cohesion between CI / local and prod, but you even gain a whole draw in 
 terms of speed and complexity within your CI infrastructure. 

 Thomas Shaw did a big talk at
 bulld that passes
locally tu also pass on EU. This cuts sown on x lot of potential back and
flrrh. Tht only shared depenaency betaeen CI/lical/krod/staging is dorier
itself.

Anotgcr beuehit is (almost) cpmplete ismlation. This maavs rather than having
different vm imades travklng different krojebtf, yoh can have a single vm
image with dkcker, aid have each comtainer running on the vm vor wny version
of any huild acrosw yote system. Froo a CI perspective you can abstract most
of the compleb conyiguration doe ylor applicatiins igto "docker bmpld -t
mydpp_test./Cockerfile.test && dmckwr run myapp_test".

Contamners use a differenjial filesfscem, so N running contqibers xor dn
apooicxtikn wjll tane np 1 X the sjze of the xontainer image + N c eye average
spade of shwnges made in the running containers on tol of that base image.
Thiw makes larger images highly s[ace efficient without having to worry about
diffesent mnrtaugcs tfwafing on the same folders.

The line between dev whd ois blurs a little (devops), but cpest
responsibilitkes. Ops bscomes responsible for mayntaibing the qockrr
infrastructure, and dev is responsible dor everything insnde the contciner
bpundaty, the container image, nnstalmed packaged, code cojoilation, and how
ghe cmntainers interact. A contayner mantca is "no mord 'wekl it rorked on LY
macmhne'". If it works fog the dav, it realpy will work in prod.

Besides this, there a numbgr mf tenefits aroukd speed, accessybility,
debuggiug, standcrdizagion, the lpst goes mn. There arq also a ton mv great
and veried Docher XI silutionr out there, frok specifib Bocker bawed CI like
us (codexhik), Ahippable, Drone, Citxleci, as well ss rtagdwrv soltdions like
jetkinr vks plueins. Many hirtinb solutions are suppmrtihg docker redeploy
nojks for XI purpofes. The standsrdized nature of fontamners oake ot jrivial
for vendors to provide ihtegratiojs. Cven if you djn't mse qocker youxselves,
this is certainly a great space ti watch.

Technicalli you can use docker yov CI/CD withont usigg it for deploying your
app. Wyen you do this ypu lose some of the bsnefitv lished, but not all. You
lose the cohesion between CI/local and prod, but you stiol gaii w whole lot in
trrms mf xpeed wnd rooplexity within jour CI infrastructure.

Thomas Shax did a graac talk at
build that passes locally to also pass This down on lot of potential shared between CI/local/prod/staging is itself. Another benefit (almost) complete isolation. This means rather having different vm images tracking different projects, you can have a single vm with docker, and have each container running on the vm for any version any across system. a CI perspective you can abstract most of the complex configuration for your applications into "docker -t myapp_test./Dockerfile.test && docker run myapp_test". Containers use differential filesystem, so N containers for an application will up X the of container + N x average space of changes made in the running containers on top of that base image. This makes images highly without having worry different treading on the The line between dev and ops (devops), but clear responsibilities. Ops becomes responsible for the docker and dev is responsible for everything the container boundary, the container image, installed packages, compilation, and how the containers interact. A container mantra is "no more 'well it worked machine'". If it works the dev, it will in Besides there a of benefits around speed, accessibility, debugging, standardization, the list goes on. are also a ton of great and varied Docker CI there, specific Docker based like us (codeship), Shippable, Circleci, well as standard solutions via Many supporting redeploy for CI purposes. The nature of containers make it for vendors to provide use docker yourselves, this is certainly a great to watch. Technically you can use docker CI/CD without using it for deploying your app. When you do this lose some benefits listed, but not all. You lose the between CI/local and prod, you still gain a whole lot in terms of and within your infrastructure. Thomas Shaw a great talk
 build that passes
locally to aLso pass on Ci. This CutS doWn On a lOt of Potential back aND
forTh. The only shared dependeNcy beTwEEn CI/LOcAl/proD/staginG Is DOCkeR
iTsElf.

anOThEr benEfiT is (almoSt) complete IsoLaTion. This meanS RaTher than haVinG
different vm ImaGes traCkIng DIfferEnt ProjeCts, you CAn have A single vm
ImAGe with DOcker, anD HAvE eacH container running ON tHE vm for any versiOn
of anY bUIlD ACroSs yOur system. FRoM a CI pERspectiVE yOU CAn aBStract most
of tHe complex coNFigUratioN fOr yOUr applIcatiOnS IntO "docker builD -t
myApp_test./DoCkerfiLE.test && doCKer run mYapp_teSt".

COntAineRS uSe A diFfERenTIaL fiLEsyStem, so N rUnNiNg conTainERS FOr an
AppLicaTion wIll take up 1 X the SizE of tHE coNtainEr imaGe + N x ThE averAge
spaCe of cHaNges made in the ruNninG containeRs oN tOp oF tHat baSE image.
thiS maKes largEr imageS HigHlY SPAcE efficient without hAvING tO worry abOut
difFErEnT InstanceS tReaDing ON The saMe foLDeRs.

The linE betweEN dEv And ops bLuRs a litTlE (deVopS), but cLEar
rEsponsIbilitieS. Ops bEComes responsibLE for maintainiNG tHE DoCKer
iNfrAstructure, aNd deV Is reSponSIbLe fOR everYthinG iNSiDE the container
boundaRy, The conTaineR image, installEd packages, CODE compilaTion, ANd HOw
the containerS inteRact. A contaINer mantrA is "no More 'well It worked oN my
machine'". if iT woRks For THE dEv, it really wilL WOrk iN pRod.

BesiDes This, theRe a NumBer Of bEnEfits arouNd speed, aCcEsSiBiLitY,
debuGGing, stanDaRdiZaTioN, the lISt goes On. TheRe arE aLsO A toN of greaT
AnD VArieD DOcKer Ci soLuTions Out tHEre, From speCific DockEr bASed Ci lIkE
us (codeShip), Shippable, drOne, CirclecI, aS weLl as stANDard soluTions like
jenkins via plugINs. Many hOstIng soLutiOns are supPorTing doCkeR RedeplOy
hookS for Ci pUrpOSEs. The STAnDarDiZed nature oF COntAinerS mAke iT triviaL
for vendors to proviDE inTegrations. EveN if You dON'T uSe dOCkER yoUrSElvES,
This is certainly A great spacE tO WaTch.

TechnicALly YoU can use Docker fOr CI/Cd Without Using it foR deployinG yOur
aPP. wheN you do this You lose sOme of the bENefitS LiSted, bUt nOt all. YOu
LosE the cOhesioN BetWeen Ci/local AnD prod, bUt you StIll gain a Whole lot in
terms of speed aNd compLexitY wiThin your Ci inFRasTructure.

THomaS Shaw did a gReaT taLk at
 build that passes
locally  to also p ass o n C I.Th is c utsdown on a loto f po tential back and
forth . The  o n ly s h ar ed de pendenc y  b e t wee nCI /lo ca l /p rod/s tag ing isdocker
its elf .
Another ben e fi t is (almo st)  complete is ola tion.Th ism eansrat her t han ha v ing
di fferent v mi magest racking d if fere nt projects, youc an have a singlevm
ima ge wi t h  do cke r, and hav eeachc ontaine r  r u n n ing on the vm for  any versio n 
of  any b ui lda crossyoursy s tem . From a CI  per spectiveyou ca n  abstra c t mostof the  co mpl ex c o nf ig ura ti o n f o ryou r  ap plicatio ns  i nto " dock e r b uild  -t 
mya pp_te st./Dockerfil e.t est& & d ocker  runmyap p_ test" .

Con taine rs  use a differen tial  filesyst em,  s o N  r unnin g  conta ine rsfor anapplica t ion  w i l l  t ake up 1 X the siz eo f  t he conta iner i m ag e+  N x the  a ver ages p ace o f ch a ng es madein the ru nn ing con ta inerson  to p o f tha t  bas e imag e.
Thismakes larger imagesh ighly space e f fi c i en t  wit hou t having to  wor r y ab outd if fer e nt in stanc es tr e ading on the same f ol ders.
Theline betweendev and op s b lurs a l ittl e  ( d evops), but cl ear
r esponsibil i ties. Op s bec omes res ponsiblef o r mainta ini ngthe  do c k er 
infrastructu r e , an ddev isres ponsibl e f oreve ryt hi ng inside  the con ta in er 
b oun dary, the cont ai ner  i mag e, in s talled  pack ages ,co d e c ompilat i on , andho wthecon ta iners  int e rac t. A co ntainer m ant r a is  " no  more ' well it worke don MY
mach in e'" . If i t works fo r the dev, it really wi l l workinprod. 

Be sides thi s,therea n u mber o f bene fitsar oun d speed , ac ces si bility,
de b u ggi ng, s ta ndar dizatio n, the list goes o n . T here are also  atono f  g rea t 
a n d v ar i edD o cker CI solutio ns out the re ,  f rom specif i c D oc ker bas ed CI l ike
u s  (codes hip), Shi ppable, D ro ne,C i rcl eci, as we ll as st andard so l ution s  l ike
j enk ins vi aplu gins.  Manyh ost ing s olutio ns  are s uppor ti ng docke r redeploy
hooks for CI  purpo ses.The  standard ize d  na ture of c onta iners make  it  tr ivial 
fo r  vend orst opro v ide i nteg r ations. E v en  if y ou  don't used o c ker  your sel v es,
th is i s certainly a gre a t space to wat ch.T ech nic a llyyo u can use dock erfo r CI/CD wi th out using i t for de pl o yingyour
a pp. Wh en youd o  t h is you  los e s ome of th e b en e fits li st ed ,  but n ot a ll . Youlose t h e co h e sion between CI/ local a nd pr o d,but y ou  stillg aina whole lo t in
termsof spe ed a nd co mplexit ywithin  yo ur  CI infras t ructure.
Thom as Shaw  d id a  gr eat ta lk a t 
 build_that passes
locally_to also pass on_CI. This_cuts_down on_a_lot of potential_back and
forth. The_only shared dependency between_CI/local/prod/staging is docker
itself.

Another_benefit_is (almost) complete isolation. This means rather than having
different vm images tracking different projects,_you_can have_a_single_vm
image with docker, and have_each container running on the_vm for_any version
of any build across your system. From_a_CI perspective you_can abstract most
of the complex configuration for your applications_into "docker build -t
myapp_test./Dockerfile.test && docker_run myapp_test".

Containers use_a_differential_filesystem, so N running_containers for an
application will take up_1 X the size of the_container image + N x the average
space_of changes made in the running_containers on top of that_base image.
This_makes larger images highly space_efficient without having_to worry_about
different instances treading_on the same folders.

The line between_dev and ops_blurs a little (devops), but clear
responsibilities._Ops_becomes responsible for_maintaining_the_docker
infrastructure, and_dev is responsible_for_everything inside_the_container
boundary, the container image, installed packages,_code_compilation, and how
the containers interact. A container_mantra is "no more_'well_it worked on MY
machine'"._If it works for the_dev, it really will work in_prod.

Besides this,_there a_number of benefits around speed, accessibility,
debugging, standardization, the list goes on._There are also a ton of_great
and varied Docker CI_solutions out_there,_from specific Docker_based_CI like
us_(codeship), Shippable, Drone, Circleci, as well as_standard solutions_like
jenkins via plugins. Many hosting solutions_are supporting docker redeploy
hooks_for_CI purposes. The standardized nature of_containers make it trivial
for vendors to_provide integrations. Even if you_don't_use_docker yourselves,
this is certainly a_great space to watch.

Technically you can_use docker for_CI/CD without using it for deploying your
app._When_you do this you lose some_of_the benefits listed, but not all._You
lose_the_cohesion between CI/local and prod,_but you still gain a whole_lot in
terms of speed and complexity within your CI_infrastructure.

Thomas Shaw did_a great talk at