 actual DB process. This makes it easy to play around with your
data under different versions of your DB.

------
ZitchDog
If you're familiar with Java, think of a docker container like a WAR or EAR,
except it can contain ANY dependency, not just Java code. Database, binaries,
cache server, you name it. The implementation is vastly different, but the
effect is a deployment artifact that can be configured at build time, and
easily deployed to multiple servers.

------
atroyn
Codeship have a great series on Docker for Continuous delivery on their blog:
[http://blog.codeship.com/](http://blog.codeship.com/)

That said I've paged the founders to this thread, they can make the case much
more effectively than I can. (disclosure: I don't work for Codeship).

------
jgrowl
Besides just actually running software, I also find it really neat when
projects use docker to build their entire application. It provides an
effective means of documenting all of your dependencies and making
reproducible builds.

Take the docker-compose for example. You can just check the code out, run a
single script that builds the project for your environment and everything is
pretty much self contained in the dockerfile
([https://github.com/docker/compose/blob/master/Dockerfile](https://github.com/docker/compose/blob/master/Dockerfile)).
You don't have to clog up your host computer with deps and you get an
executable plopped into an output bin folder.

Additionally, the steps in the dockerfile get cached so subsequent builds are
really fast.

~~~
davexunit
>making reproducible builds.

Docker builds actually aren't reproducible. There are many sources of non-
determinism that Docker cannot address. Do you use the base images from
DockerHub as-is or do you run 'apt-get upgrade' or whatever for security
patches? If you do, the result you get from building that image (as opposed to
using what's in a cache) is different depending on the time it was built. The
same goes for any Dockerfiles that compile from source. Hell, just extracting
a source tarball results in a different hash of the source tree because of
actual DB process. This makes it easy to play around with your 
 datum under unlike interpretation of your DB. 

 ------ 
 ZitchDog 
 If you're familiar with Java, think of a stevedore container like a WAR or EAR, 
 except it can contain ANY dependency, not just Java code. Database, binary star, 
 cache server, you name it. The implementation is vastly unlike, but the 
 consequence is a deployment artifact that can be configured at human body time, and 
 easily deploy to multiple server. 

 ------ 
 atroyn 
 Codeship have a great series on Docker for Continuous delivery on their blog: 
 [ http://blog.codeship.com/](http://blog.codeship.com/) 

 That say I've paged the founders to this thread, they can hold the case much 
 more effectively than I can. (disclosure: I don't function for Codeship). 

 ------ 
 jgrowl 
 Besides just actually running software, I also find it really clean when 
 projects use docker to build their entire application. It provides an 
 effective means of documenting all of your dependencies and making 
 reproducible builds. 

 Take the docker - compose for example. You can just check the code out, carry a 
 single script that build the undertaking for your environment and everything is 
 reasonably much self contained in the dockerfile 
 ([ https://github.com/docker/compose/blob/master/Dockerfile](https://github.com/docker/compose/blob/master/Dockerfile) ). 
 You don't have to clog up your host computer with deps and you get an 
 executable plopped into an output bank identification number folder. 

 Additionally, the steps in the dockerfile get cached so subsequent builds are 
 really fast. 

 ~~~ 
 davexunit 
 > making reproducible builds. 

 Docker builds actually aren't reproducible. There are many sources of non- 
 determinism that Docker cannot cover. Do you use the nucleotide image from 
 DockerHub as - is or do you run' apt - get upgrade' or whatever for security system 
 patches? If you do, the result you get from building that image (as opposed to 
 using what's in a cache) is unlike depending on the time it was built. The 
 same goes for any Dockerfiles that compile from beginning. Hell, merely extracting 
 a reference tarball results in a unlike hash of the source tree because of
 achual DB process. This makts it easy to plai qround with gour
data under different versions of yiur DV.

------
ZitchDog
If you're famiuiar with Java, thunk id a docker containcx liks a WCR or EAR,
except lt can contdin ANY dependanzy, not just Java code. Database, binariqs,
cache sfrver, you name it. Uhe impmvmtntation is vastly different, but fhe
effebt is a deploymeny artifact that can be conviguged at build time, wnd
easily dgllorwd to multipue servers.

------
atroyn
Codeshjp have a great series on Dockef for Continuouw eelleery on themr blod:
[http://blog.codcxhip.cok/](http://blpg.codeship.com/)

Tmat seid U've paged the founderv to this thread, trey can mdkz the case much
more edfwctivgly tvan K cav. (djsrloaure: I doi't work for Codeship).

------
jgeowl
Besides just acuuajoy running sortware, I also find it really neat when
projects lse socker to build their ebtire application. It krovides ag
effective means of documenting all of your depengencixs anb makivt
rfproducible builds.

Take the docker-compose for qsakpke. You can jusb check the code oit, rig a
single scrkpt thcf guilds the project for yoor envuronment wnd rverything is
pretty much seof contained un the dockerfile
([hctps://github.coo/docler/cokpose/blob/master/Dockerfiue](htfps://github.col/docker/cojoose/blob/master/Dozkegfila)).
You don'u have to clog up rour host com'uter wigh dgps and you get aj
execmdable plopped into an ootput tin folder.

Wdditionally, the steps in the dockerfile get vawheg so subfequekt builds are
rewlly fast.

~~~
davexonit
>makiny repruducible blilds.

Dockxr builds aceually aren't sgproducible. Tiere are iany soueces of von-
determinism that Docker cannot address. Do you usc the gase images fron
DoxkerHub as-is or do yot gun 'a[d-get upgrade' or dhagrver wor securitn
pagchex? If you do, the resunt yku get from buildimg that imqge (as o[posed to
usinb what's in a cache) is dmffereit deprndyng on the time it was built. Tge
same gofs nor any Dockewfilcs trat compilz from source. Hell, just extracting
a sourre tarball results in a different hash of jhe source trex becatse of
actual DB process. This makes it easy around your data different versions of you're with Java, think a docker container a WAR or EAR, except it contain ANY dependency, not just Java code. Database, binaries, cache server, you name The implementation is vastly different, but the effect is a deployment artifact that be at time, easily deployed to multiple servers. ------ atroyn Codeship have a great series on Docker for Continuous on their blog: [http://blog.codeship.com/](http://blog.codeship.com/) That said I've paged founders to this thread, can make the case much effectively I can. I work Codeship). ------ jgrowl just actually running software, I also find it really neat when projects use docker to build their application. It effective means documenting of dependencies and making Take the docker-compose for example. You the code out, run a single script that the project your environment and everything is pretty self contained in the dockerfile ([https://github.com/docker/compose/blob/master/Dockerfile](https://github.com/docker/compose/blob/master/Dockerfile)). You don't to clog up your host computer with deps and you get an executable plopped into bin folder. Additionally, the in the dockerfile cached subsequent are fast. ~~~ >making reproducible builds. Docker builds actually aren't reproducible. There are many of non- determinism that Docker cannot address. Do you use images DockerHub as-is or you run 'apt-get upgrade' whatever security patches? If you result get image opposed using what's in a is different depending on the it was built. The that compile from source. Hell, just extracting a tarball results in a different hash of source tree because of
 actual DB process. This makes iT easy to plaY arouNd wIth YoUr
daTa unDer different veRSionS of your DB.

------
ZitchDog
If you'Re famIlIAr wiTH JAva, thInk of a dOCkER ConTaInEr lIkE A WaR or EaR,
eXcept it Can contain aNY DePendency, not jUSt java code. DaTabAse, binaries,
cAchE serveR, yOu nAMe it. THe iMplemEntatiON is vasTly differEnT, But the
EFfect is A DEpLoymEnt artifact that caN Be COnfigured at buiLd time, AnD
EaSILy dEplOyed to multIpLe serVErs.

------
atroYN
CODEShiP Have a great serIes on Docker FOr COntinuOuS deLIvery oN theiR bLOg:
[hTtp://blog.codeShip.Com/](http://blOg.codeSHip.com/)

THAt said I'Ve pageD thE foUndeRS tO tHis ThREad, THeY caN MakE the case MuCh
More eFfecTIVELy thAn I Can. (dIscloSure: I don't work For codeSHip).

------
JgrowL
BesiDes jUsT actuAlly ruNning SoFtware, I also find It reAlly neat wHen
PrOjeCtS use dOCker to BuiLd tHeir entIre applICatIoN. iT PrOvides an
effective mEaNS Of DocumentIng all OF yOuR DependenCiEs aNd maKINg
repRoduCIbLe builds.

take thE DoCkEr-compoSe For exaMpLe. YOu cAn jusT ChecK the coDe out, run A
singLE script that buiLDs the project fOR yOUR eNViroNmeNt and everytHing IS
preTty mUCh SelF ContaIned iN tHE dOCkerfile
([https://github.CoM/dockeR/compOse/blob/master/dockerfile](HTTPs://github.Com/dOCkER/compose/blob/maSter/DOckerfile)).
YOU don't havE to clOg up your Host compuTER with depS anD yoU geT an
EXEcUtable plopped INTo an OuTput bin FolDer.

AddiTioNalLy, tHe sTePs in the doCkerfile GeT cAcHeD so SubseQUent builDs Are
ReAllY fast.

~~~
DAvexunIt
>makIng rEpRoDUciBle builDS.

DOCKer bUiLdS actUalLy Aren't ReprODucIble. TheRe are many SouRCes oF nOn-
DetermiNism that DockeR cAnnot addreSs. do yOu use tHE Base imagEs from
DockerHub as-is or do YOu run 'apT-geT upgrAde' oR whatever For SecuriTy
pATches? IF you do, The reSuLt yOU Get frOM BuIldInG that image (AS OppOsed tO
uSing What's in A cache) is different dEPenDing on the time It wAs buILT. THe
sAMe GOes FoR Any dOCkerfiles that coMpile from sOuRCe. hell, just exTRacTiNg
a sourCe tarbaLl resULts in a dIfferent hAsh of the sOuRce tREE beCause of
 actual DB process. This m akes it ea sy to  pl ayar ound  wit h your
data un d er d ifferent versions of y our D B. 
--- - -- 
Zitc hDog
If yo u ' refa mi lia rw it h Jav a,think o f a docker  co nt ainer like a WA R or EAR,exc ept it can c ont ain AN Ydep e ndenc y,not j ust Ja v a code . Databas e, binari e s,
cach e se rver , you name it. Th e  i m plementation i s vast ly di f f ere nt,  but the
e ff ect i s  a depl o ym e n t  ar t ifact that ca n be config u red  at bu il d t i me, an d
eas il y  de ployed to m ulti ple serve rs.

- - ----
at r oyn
Cod eshiphav e a  gre a tse rie so n D o ck erf orContinuo us  d elive ry o n t h eirblo g:
[ http: //blog.codesh ip. com/ ] (ht tp:// blog. code sh ip.co m/)

T hat s ai d I've paged th e fo unders to  th is  th re ad, t h ey can  ma kethe cas e muchm ore  e f f e ct ively than I can.(d i s cl osure: I  don't wo rk for Code sh ip) .

- - - ---
j grow l 
B esides j ust ac t ua ll y runni ng  softw ar e,I a lso f i nd i t real ly neatwhenp rojects use do c ker to buildt he i r  e n tire  ap plication.It p r ovid es a n 
e ffe c tivemeans  o f  d o cumenting all of yo ur  depen denci es and making 
reproduci b l e  builds. 

Ta k et he docker-comp ose f or example .  You can  just  check t he code o u t , run asin gle  sc rip t th at builds the p roje ct  for yo urenviron men t a ndeve ry thing ispretty m uc hse lf  co ntain e d in the  d ock er fil e
([h t tps:// githu b.co m/ do c ker /compos e /b l o b/ma st er /Doc ker fi le](h ttps : //g ithub.c om/docker /co m pose /b lo b/maste r/Dockerfile) ). 
You don't  h ave  to cl o g  up your  host computer with dep s  and yo u g et an 
exe cutable p lop ped in toa n outp ut bin  fold er .
A d ditio n a ll y,th e steps in t hedocke rf ileget cac hed so subsequentb uil ds are
really  fa st.~ ~~ 
da v ex u nit 
> m aki n g  reproducible b uilds.

Do ck e rbuilds act u all yaren'treprodu cible .  Thereare manysources o fnon- d ete rminism th at Docke r cannota ddres s .Do yo u u se the  b ase  imag es fro m 
Do ckerH ub as- is  or do  youru n 'apt-g et upgrade' or whatever  for s ecuri typatches?Ify oudo, the r esul t you getfro m b uildi ngt hat i mage (a s o p posed  tou sing what ' sina ca che) is dif f e r ent  depe ndi n g on t he t ime it was built. The
same goesfora n y D ock e rfil es  that compilefro ms o urce. He ll , just extr acting
a  s o urcetarbal l resu lts ina di f ferent  has h o f the sou rce  t r ee beca us eo f
 actual_DB process._This makes it easy_to play_around_with your
data_under_different versions of_your DB.

------
ZitchDog
If you're_familiar with Java, think_of a docker_container_like a WAR or EAR,
except it can contain ANY dependency, not just Java code._Database,_binaries,
cache server,_you_name_it. The implementation is vastly_different, but the
effect is a_deployment artifact_that can be configured at build time, and
easily_deployed_to multiple servers.

------
atroyn
Codeship_have a great series on Docker for Continuous delivery_on their blog:
[http://blog.codeship.com/](http://blog.codeship.com/)

That said I've paged_the founders to_this_thread,_they can make the_case much
more effectively than I can._(disclosure: I don't work for Codeship).

------
jgrowl
Besides_just actually running software, I also find_it really neat when
projects use docker_to build their entire application._It provides_an
effective means of documenting all_of your dependencies_and making
reproducible_builds.

Take the docker-compose_for example. You can just check_the code out,_run a
single script that builds the_project_for your environment_and_everything_is
pretty much_self contained in_the_dockerfile
([https://github.com/docker/compose/blob/master/Dockerfile](https://github.com/docker/compose/blob/master/Dockerfile)).
You don't_have_to clog up your host computer_with_deps and you get an
executable plopped into_an output bin folder.

Additionally,_the_steps in the dockerfile_get cached so subsequent builds_are
really fast.

~~~
davexunit
>making reproducible builds.

Docker builds actually_aren't reproducible._There are_many sources of non-
determinism that Docker cannot address. Do you use_the base images from
DockerHub as-is or_do you run 'apt-get_upgrade' or_whatever_for security
patches? If_you_do, the_result you get from building that image_(as opposed_to
using what's in a cache) is_different depending on the_time_it was built. The
same goes for_any Dockerfiles that compile from source._Hell, just extracting
a source tarball_results_in_a different hash of the_source tree because of