This document discusses Dockerizing Symfony applications. It introduces Docker containers as a lightweight virtualization method using Linux namespaces and union filesystems. It then demonstrates how to containerize the components of a sample Symfony app - Redis, PHP-FPM, Nginx - connecting them using Docker links and volumes. Fig is introduced as a tool to define and run multi-container Docker environments using a YAML configuration file, making management of the Symfony app containers easier. Hosting challenges are mentioned along with an invitation to join Giantswarm's private beta for container management.

1. Dockerizing
Symfony Apps
Dennis Benkert
@denderello

2. Set out to make service orchestration
simple for developers.
Based in Cologne, Germany.
Ten terrific folks, and hiring!
http://giantswarm.io/

3. So, Docker ...
It’s that new kid everybody talks about

4. Ever heard about
it?

5. IT’S FUN!

6. It will help you to ...
● run your environment everywhere
● try out infrastructure changes easier
● deploy new releases faster
● run PHP without installing it locally!

7. How is that
possible?

8. Docker
Containers!

9. Docker’s
Building Blocks
Watch out. Linux Kernel ahead!

10. What are Docker
Containers?

11. Linux Containers
+
Union Filesystems

12. Linux Containers?

13. Remember
Virtual Machines?

14. They use
Hypervisors

15. Hypervisors
virtualize
a whole system

16. Virtual Machines
Machine
Kernel
Init
Hypervisor
VM
Kernel
Init
Process
VM
Kernel
Init
VM
Kernel
Init
Process
Process
Process
Process
Process

17. Try to start 100 of
them on your
laptop … ;-)

18. Linux Containers
are lightweight
virtualization

19. Linux Containers ...
● run in their own Kernel namespace
● are standalone processes
● only see processes inside them
● cannot see outside processes
● share the kernel instance
● can have their own filesystem
● can be isolated using CGroups

20. Linux Containers
Machine
Kernel
Init
Container
Process
Container
Process
Container
Process

21. Union Filesystem?

22. Think of stacked
layers

23. Every
write operation
opens a new layer

24. Union filesystem
Change /etc/php5/fpm/php.ini
Install PHP-FPM
Basic Ubuntu RootFS

25. You will see a
combined view of
all layers

26. Imagine your
webserver is a
layer

27. And every project
release becomes a
layer on top

28. Run this
filesystem as a
single process

29. You have
Docker
Containers!

31. Docker Containers is
chroot on steroids.”
— Jérôme Petazzoni (Docker) “

32. Sounds hard to
achieve?

33. Docker makes this
super easy!

34. Four steps needed

35. 1. Create a PHP file
<?php
echo "Hello from PHP";

36. 2. Create a Dockerfile
FROM php
ADD index.php /var/www
EXPOSE 8080
WORKDIR /var/www
Every line
becomes a layer
ENTRYPOINT ["php", "-S", "0.0.0.0:8080"]

37. 3. Build your Container
$ docker build -t denderello/phptest .

38. 4. Run your Container
$ docker run -d -p 8080:8080 denderello/phptest
$ curl 127.0.0.1:8080
Hello from PHP
Binds local port
to exposed port

39. You can run this
Container
everywhere!

40. The Dockerhub saves your Containers
D
push run
Dev Prod
Docker daemon Docker daemon
Docker client Docker client

41. Let’s get started
Symfony, get ready to become dockerized!

42. Imagine a simple
Symfony app

43. Redis
nginx / fpm
Symfony
A classic setup

44. Let’s break this up
into processes

45. Seperate the processes
Redis fpm
nginx

46. Every process
becomes a
container

47. Wait

48. nginx and fpm
need to share the
source files

49. Incorporation of nginx and PHP-FPM
nginx
fpm
Symfony

50. Let’s add a
volume container

51. Volume containers
share folders with
other containers

52. Define the containers
Redis fpm
nginx
Symfony

53. Redis

54. Redis Container
$ docker run -d -p 6379:6379
--name redis redis:2.8.13

55. Define the containers
Redis

56. Symfony

57. Symfony Container
FROM ubuntu:14.04
RUN apt-get update && apt-get install -y
git curl php5-cli php5-json php5-intl
RUN curl -sS https://getcomposer.org/installer | php
RUN mv composer.phar /usr/local/bin/composer
ADD entrypoint.sh /entrypoint.sh
ADD ./code /var/www
VOLUME /var/www
WORKDIR /var/www
ENTRYPOINT ["/entrypoint.sh"]
CMD ["echo", "hello"]

58. Entrypoint Bash Script
#!/bin/bash
rm -rf /var/www/app/cache/*
/bin/bash -l -c "$*"

59. Run the Symfony Container
$ docker run denderello/symfony composer install
$ docker run denderello/symfony
app/console cache:clear

60. No PHP on the
local machine
anymore

61. Define the containers
Redis
Symfony

62. PHP-FPM

63. php-fpm Container
FROM ubuntu:14.04
RUN apt-get update && apt-get install -y
php5-fpm php5-json php5-intl
ADD entrypoint.sh /entrypoint.sh
EXPOSE 9000
WORKDIR /var/www
ENTRYPOINT ["/entrypoint.sh"]

64. Configure your
app with
environment
variables

65. Entrypoint Bash Script
#!/bin/bash
echo "env[SYMFONY__REDIS_PORT] = ${REDIS_PORT_6379_TCP_PORT}"
>> /etc/php5/fpm/pool.d/www.conf
echo "env[SYMFONY__REDIS_ADDRESS] = ${REDIS_PORT_6379_TCP_ADDR}"
>> /etc/php5/fpm/pool.d/www.conf
exec /usr/sbin/php5-fpm --nodaemonize
Docker will set
these for links

66. Docker links?

67. Containers have
no open ports by
default

68. Exposed ones can
be opened to the
host

69. Links open
exposed ports
between two
containers

70. They will not be
open to the host

71. Run the fpm Container
$ docker run -d denderello/fpm
--link redis:redis
--volumes-from symfony
--name fpm

72. Define the containers
Redis
fpm
Symfony

73. nginx

74. nginx Container
FROM ubuntu:14.04
RUN apt-get update && apt-get install -y
nginx
RUN echo "ndaemon off;" >> /etc/nginx/nginx.conf
ADD vhost.conf /etc/nginx/sites-enabled/default
ADD entrypoint.sh /entrypoint.sh
EXPOSE 80
ENTRYPOINT ["/entrypoint.sh"]

75. Run the nginx Container
$ docker run -d denderello/nginx
--link fpm:fpm
--volumes-from symfony
--name nginx

76. The final containers
Redis fpm
nginx
Symfony

77. Running this setup
requires 4 cli
commands

78. This can be done
easier

79. Fig

80. Fast, isolated
development
environments using
Docker”
— The Fig Website
“

81. Define your
environment using
YAML

82. fig.yml (excerpt)
…
nginx:
build: nginx/
ports:
- 8080:80
links:
- fpm
volumes_from:
- symfony
…

83. fig.yml (excerpt)
…
symfony:
build: symfony/
links:
- redis
volumes:
- ./symfony/code:/var/www
…
Overrides the the
folder when running
the container

84. Starting all
containers is just
a command away

85. Using fig
$ fig up

86. Running Symfony
commands is
easier

87. Using fig
$ fig run symfony composer install
$ fig run symfony app/console cache:clear

88. Hosting this is still
a challenge

89. But there is
company setting
out to change this

90. Sign up for our
private Beta
Request Invite
http://giantswarm.io/

91. Thanks for listening!
Reach out:
Dennis Benkert
@denderello
@giantswarm