Video and slides synchronized, mp3 and slide download available at URL http://bit.ly/1W22OMy. Jerome Petazzoni explains in detail the advantages of immutable servers, then how to implement them with containers in general, and Docker in particular. Filmed at qconnewyork.com. Jerome Petazzoni is a senior engineer at Docker, where he helps others to containerize all the things. In another life he built and operated Xen clouds when EC2 was just the name of a plane, developed a GIS to deploy fiber interconnects through the French subway, managed commando deployments of large-scale video streaming systems in bandwidth-constrained environments such as conference centers.

1. Immutable
infrastructure
with Docker and
containers
1 / 58

2. InfoQ.com: News & Community Site
• 750,000 unique visitors/month
• Published in 4 languages (English, Chinese, Japanese and Brazilian
Portuguese)
• Post content from our QCon conferences
• News 15-20 / week
• Articles 3-4 / week
• Presentations (videos) 12-15 / week
• Interviews 2-3 / week
• Books 1 / month
Watch the video with slide
synchronization on InfoQ.com!
http://www.infoq.com/presentations
/immutable-servers-docker

3. Presented at QCon New York
www.qconnewyork.com
Purpose of QCon
- to empower software development by facilitating the spread of
knowledge and innovation
Strategy
- practitioner-driven conference designed for YOU: influencers of
change and innovation in your teams
- speakers and topics driving the evolution and innovation
- connecting and catalyzing the influencers and innovators
Highlights
- attended by more than 12,000 delegates since 2007
- held in 9 cities worldwide

4. Who am I?
Jérôme Petazzoni (@jpetazzo)
French software engineer living in California
Joined Docker (dotCloud) more than 4 years ago
(I was at Docker before it was cool!)
I have built and scaled the dotCloud PaaS
I learned a few things about running containers
(in production)
2 / 58

5. Outline
What is immutable infrastructure?
What are its pros and cons?
How can it be implemented with containers?
Also: demos!
3 / 58

6. Immutable
infrastructure
(a.k.a. immutable servers,
phoenix servers, etc.)
4 / 58

7. Rule 1: never change what's on a server
Don't install new packages
Don't upgrade existing ones
Don't remove or downgrade them
(Even for security vulnerabilities!)
Don't edit configuration files
Don't update your app code
(Even for small or urgent fixes!)
5 / 58

8. Rule 2: if tempted to change something...
See Rule 1
(OK, we will see an exception later.)
6 / 58

9. How do we upgrade?
Create new server from scratch
Apply deployment process*
(scripts, configuration management...)
(Optional: test the new server)
Replace old server with new server
Keep old server around, just in case
* Configuration management helps, but is not mandatory here.
7 / 58

10. WHY?!?
8 / 58

11. Avoid drift
9 / 58

12. Avoid drift
10 / 58

13. Avoid drift
Drift = differences between servers
(when they are supposed to be identical)
Caused by:
provisioning servers at different times
any manual operation
Consequences:
seemingly random failures
same code, different behavior
gets worse with time
11 / 58

14. Coping with drift
Careful replication of manual operations doesn't scale
(and is error-prone)
Automation seems simple at first,
but has to deal with many edge cases
Configuration management helps,
but only deals with what you've defined
12 / 58

15. Automation fails
"Let's use parallel-ssh!" (Or your favorite tool)
What if some servers...
are unreachable
become unreachable during the process
are being provisioned at the same time
What if one of those services is (partially) down?
distro package repositories
code or artifact repositories
13 / 58

16. Config management fails
package{"openssl":ensure=>"installed"}
14 / 58

17. Config management fails
package{"openssl":ensure=>"installed"}
A wild OpenSSL vulnerability appears!
15 / 58

18. Config management fails
package{"openssl":ensure=>"installed"}
A wild OpenSSL vulnerability appears!
package{"openssl":ensure=>"1.0.1g"}
16 / 58

19. Config management fails
package{"openssl":ensure=>"installed"}
A wild OpenSSL vulnerability appears!
package{"openssl":ensure=>"1.0.1g"}
Something went wrong, abort, abort!
17 / 58

20. Config management fails
package{"openssl":ensure=>"installed"}
A wild OpenSSL vulnerability appears!
package{"openssl":ensure=>"1.0.1g"}
Something went wrong, abort, abort!
package{"openssl":ensure=>"installed"}
18 / 58

21. Config management fails
package{"openssl":ensure=>"installed"}
A wild OpenSSL vulnerability appears!
package{"openssl":ensure=>"1.0.1g"}
Something went wrong, abort, abort!
package{"openssl":ensure=>"installed"}
We didn't roll back to whatever-we-had!
19 / 58

22. Config management fails
package{"openssl":ensure=>"installed"}
A wild OpenSSL vulnerability appears!
package{"openssl":ensure=>"1.0.1g"}
Something went wrong, abort, abort!
package{"openssl":ensure=>"installed"}
We didn't roll back to whatever-we-had!
package{"openssl":ensure=>"1.0.1f"}
20 / 58

23. Config management fails
package{"openssl":ensure=>"installed"}
A wild OpenSSL vulnerability appears!
package{"openssl":ensure=>"1.0.1g"}
Something went wrong, abort, abort!
package{"openssl":ensure=>"installed"}
We didn't roll back to whatever-we-had!
package{"openssl":ensure=>"1.0.1f"}
This should do the trick. (Hopefully.)
21 / 58

24. More nightmares
package{"openssl":ensure=>"1.0.1f"}
22 / 58

25. More nightmares
package{"openssl":ensure=>"1.0.1f"}
Package not found on the repos.
23 / 58

26. More nightmares
package{"openssl":ensure=>"1.0.1f"}
Package not found on the repos.
"Well, actually" we want an older version.
24 / 58

27. More nightmares
package{"openssl":ensure=>"1.0.1f"}
Package not found on the repos.
"Well, actually" we want an older version.
Package even less likely to be found on the repos.
25 / 58

28. More nightmares
package{"openssl":ensure=>"1.0.1f"}
Package not found on the repos.
"Well, actually" we want an older version.
Package even less likely to be found on the repos.
"Well, actually" we were using 0.9.8xxx.
When we requested 1.0.1g we upgraded the whole distro.
26 / 58

29. More nightmares
package{"openssl":ensure=>"1.0.1f"}
Package not found on the repos.
"Well, actually" we want an older version.
Package even less likely to be found on the repos.
"Well, actually" we were using 0.9.8xxx.
When we requested 1.0.1g we upgraded the whole distro.
(╯°□°）╯︵ ┻━┻)
27 / 58

30. With immutable servers
We still have the old server
Just put it back into service
(while we figure out the OpenSSL upgrade!)
Also works for any kind of upgrade
that needs to be rolled back
Alright, we have easy rollbacks.
But how does that help with drift?
28 / 58

31. "Trash your servers and burn your code"
(Chad Fowler)
Reprovision your servers regularly
(from scratch)
Ensures that you're always using recent packages
Any manual deviation gets fixed automatically
29 / 58

32. Improvement: golden image
Create a server from scratch
Apply deployment process
Snapshot this server (create an image)
(Optional: create a test server and validate it)
Create multiple identical servers from the image
Avoids uncertainties in the deployment process:
unreachable packages repositories etc.
Allows to keep (for cheap) past versions around.
30 / 58

33. Downsides
(and how to cope)
31 / 58

34. Problem: small changes are cumbersome
E.g. one line of CSS.
Before: manual change, validate, replicate
(a few minutes)
After: manual change, validate, ...
create new golden image from scratch
(one hour)
provision new servers from image
(a few minutes)
switch old/new servers
decommission old servers after a while
32 / 58

35. Solution: automation
All those operations have to happen
But everything after the "validate" step
should be automated
The clock time will still be 1+ hour
The user time will be a few minutes
(just like before)
Note: intermediary golden images can help
(provision from checkpoint instead of from scratch)
33 / 58

36. Problem: debugging is harder
E.g. troubleshoot network issues.
Before:
install tcpdump
fiddle with iptables
accumulate logs and packet captures locally
After:
install tcpdu-oops, the server was re-imaged
fiddle with ipta-oops, ...
logs and traces have to be shipped out
34 / 58

37. Solution 1: drift and self-destruct
Tag a given machine to prevent its "re-imaging"
Schedule it for self-destruct after e.g. 1 week
(shutdown+10000)
That machine is allowed to drift
(you can install your tools on it,
leave logs and traces locally...)
If you need more time, reschedule the self-destruct
35 / 58

38. Solution 1: drift and self-destruct
Tag a given machine to prevent its "re-imaging"
Schedule it for self-destruct after e.g. 1 week
(shutdown+10000)
That machine is allowed to drift
(you can install your tools on it,
leave logs and traces locally...)
If you need more time, reschedule the self-destruct
If you find yourself setting up a cron job to reschedule the self-
destruct, you're doing it wrong!
36 / 58

39. Solution 2: bundle the tools
Install tcpdumpand friends in the golden image
Enable traffic capture with feature switch
(Alternate solution: statistical sampling)
Automate shipping of logs and traces
It's more work in the beginning, but pays in the long run.
37 / 58

40. Problem: storing data
Databases and anything stateful!
Before: just store it locally
After: need to persist it somehow
38 / 58

41. Solution 1: not my problem
"Often you can pass the buck to a service which someone else
maintains, like Amazon's RDS database service."
(Kief Morris)
Easy!
But what if:
there is no such service
I can't use it for $REASONS?
39 / 58

42. Solution 2: state = files
All you need is a mechanism to store files externally.
NAS/SAN (on-prem)
EBS, EFS (AWS)
Ceph, Gluster... (anywhere)
But it's extra work, expensive, and/or slower.
40 / 58

43. Solution 3: ?
41 / 58

44. Solution 3: ?
SPOILER ALERT
42 / 58

45. Solution 3
43 / 58

46. Immutable
containers
44 / 58

47. Let's review our process
Create image:
from scratch
(can take an hour or more)
from checkpoint
(takes a few minutes, more complex)
Deploy it N times
(takes a few minutes)
How do we do that with containers?
45 / 58

48. Building container images
We get the best of both worlds:
from scratch
(clean rebuilds without side-effects)
incremental
(fast rebuilds when changes are minor)
Why and how?
container snapshots are cheap
(seconds versus minutes)
simple DSL to break down the build into steps
(each step = one command = one snapshot)
46 / 58

49. FROMdebian:jessie
MAINTAINERJessicaFrazelle<jess@docker.com>
#Installdependencies
RUNapt-getupdate&&apt-getinstall-y
build-essential
…
--no-install-recommends
#Installnode
RUNcurl-sLhttps://deb.nodesource.com/setup|bash-
RUNapt-getinstall-ynodejs
#Cloneatom
RUNgitclonehttps://github.com/atom/atom/src
WORKDIR/src
RUNgitfetch&&gitcheckout
$(gitdescribe--tags
`gitrev-list--tags--max-count=1`)
RUNscript/build&&script/gruntinstall
#Autorunatom
CMD/usr/local/bin/atom--foreground
47 / 58

50. What happens during the first build?
FROMdebian
RUNapt-getxxx
COPY./src
RUN/src/build
Create a container from debianbase image
Execute apt-getxxxin this container, take a snapshot
Create a container from this snapshot
Copy source files into /src, take a snapshot
Create a container from this snapshot
Execute /src/buildin this container, take a snapshot
The final snapshot is our built image.
48 / 58

51. What happens during subsequent builds?
Before executing each step:
check if we already executed the same step before
(and have a snapshot of its result)
if we do, use the snapshot and continue
otherwise, execute the step normally
(and snapshot the result)
As a result, we zoom through the build process,
until we hit a step that has changed
The end result is the same as a full clean build,
but much faster
49 / 58

52. Demo
50 / 58

53. Running container images
On physical or virtual machines
Run multiple containers per machine
Upgrading is faster
(doesn't have to wait for IaaS VM to come up)
Can reuse local data (Docker concept: "volumes")
Solves the stateful service problem
51 / 58

54. Demo
52 / 58

55. Bonus
Containers can share:
directories (e.g.: logs)
network stack (e.g.: traffic analysis)
... and more!
Logging, backups, metrics collection, troubleshooting...
can be done from "sidekick" containers.
53 / 58

56. Demo
54 / 58

57. Other niceties
Containers filesystem can be made read-only
enforces immutability
exception for data volumes (with noexec)
easier security audit
Cheaper
consolidation
save a few ¢ or $ per server per deploy
(great if your IAAS bills by the hour)
55 / 58

58. Conclusions
56 / 58

59. Immutable containers
All the advantages of immutable servers
(avoid drift, reliable rollbacks...)
Build in seconds instead of minutes/hours
Faster, simpler deployment
Deal with stateful services
Bonus: cheaper, safer, cleaner
57 / 58

60. Thanks!
Questions?
@jpetazzo
@docker
58 / 58

61. Watch the video with slide
synchronization on InfoQ.com!
http://www.infoq.com/presentations/
immutable-servers-docker