Comme vous nous l'avez demandé, voici nos slides sur la conférence Elixir du 21 septembre 2017 à Paris.

1. Nos premiers mois
avec Elixir
Joan Zapata
@joanzap
Raphaël Lustin
@raphilustin

2. TrustBK

3. TrustBK
Cible les PME
From scratch, pas de dette technique
Repense la relation banquier-client
Confiance, technologie, éthique

4. On recrute !
trustbk.com/jobs

5. Nos premiers mois
• Découvrir le langage et son écosystème
• Trouver nos bonnes pratiques
• Apprendre à tester et à livrer en production

6. Découvrir le langage

7. Scénario 1
Gestion d’erreur

8. Scénario 1
GET /api/accounts/1
authorization: Bearer 12345678
GET /api/accounts/1
authorization: Bearer WRONG_TOKEN
401
200
Controller
Controller
Controller
Controller
Plug
SERVEUR

9. defmodule BackendWeb.Router do
scope "/api", BackendWeb do
get "/accounts/:id", AccountsController, :get_one
end
end

10. defmodule BackendWeb.Router do
scope "/api", BackendWeb do
get "/accounts/:id", AccountsController, :get_one
end
end

11. defmodule BackendWeb.Router do
pipeline :authenticate do
plug Backend.Plug.Authenticate
end
scope "/api", BackendWeb do
get "/accounts/:id", AccountsController, :get_one
end
end

12. defmodule BackendWeb.Router do
pipeline :authenticate do
plug Backend.Plug.Authenticate
end
scope "/api", BackendWeb do
pipe_through :authenticate
get "/accounts/:id", AccountsController, :get_one
end
end

13. Backend.Plug.Authenticate

14. defmodule Backend.Plug.Authenticate do
@behaviour Plug
def init(opts), do: opts
def call(conn, _opts %{})
end

15. def call(conn, _opts %{}) do
end

16. def call(conn, _opts %{}) do
authorization_headers = get_req_header(conn, "authorization")
end

17. def call(conn, _opts %{}) do
authorization_headers = get_req_header(conn, "authorization")
{:ok, token} = get_token(authorization_headers)
end

18. def call(conn, _opts %{}) do
authorization_headers = get_req_header(conn, "authorization")
{:ok, token} = get_token(authorization_headers)
{:ok, session: session, user: user} = Auth.authenticate(token)
end

19. def call(conn, _opts %{}) do
authorization_headers = get_req_header(conn, "authorization")
{:ok, token} = get_token(authorization_headers)
{:ok, session: session, user: user} = Auth.authenticate(token)
end

20. def call(conn, _opts %{}) do
authorization_headers = get_req_header(conn, "authorization")
{:ok, token} = get_token(authorization_headers)
{:ok, session: session, user: user} = Auth.authenticate(token)
conn
|> assign(:current_user, user)
|> assign(:current_session, session)
end

21. def call(conn, _opts %{}) do
authorization_headers = get_req_header(conn, "authorization")
{:ok, token} = get_token(authorization_headers)
{:ok, session: session, user: user} = Auth.authenticate(token)
conn
|> assign(:current_user, user)
|> assign(:current_session, session)
end

22. def call(conn, _opts %{}) do
authorization_headers = get_req_header(conn, "authorization")
case get_token(authorization_headers) do
{:ok, token} ->
{:ok, session: session, user: user} = Auth.authenticate(token)
conn
|> assign(:current_user, user)
|> assign(:current_session, session)
{:error, error} ->
conn
|> put_status(:unauthorized)
|> render(ErrorView, "401.json", %{})
|> halt()
end
end

23. def call(conn, _opts %{}) do
authorization_headers = get_req_header(conn, "authorization")
case get_token(authorization_headers) do
{:ok, token} ->
{:ok, session: session, user: user} = Auth.authenticate(token)
conn
|> assign(:current_user, user)
|> assign(:current_session, session)
{:error, error} ->
conn
|> put_status(:unauthorized)
|> render(ErrorView, "401.json", %{})
|> halt()
end
end

24. def call(conn, _opts %{}) do
authorization_headers = get_req_header(conn, "authorization")
case get_token(authorization_headers) do
{:ok, token} ->
{:ok, session: session, user: user} = Auth.authenticate(token)
conn
|> assign(:current_user, user)
|> assign(:current_session, session)
{:error, error} ->
conn
|> put_status(:unauthorized)
|> render(ErrorView, "401.json", %{})
|> halt()
end
end

25. def call(conn, _opts %{}) do
authorization_headers = get_req_header(conn, "authorization")
case get_token(authorization_headers) do
{:ok, token} ->
{:ok, session: session, user: user} = Auth.authenticate(token)
conn
|> assign(:current_user, user)
|> assign(:current_session, session)
{:error, error} ->
conn
|> put_status(:unauthorized)
|> render(ErrorView, "401.json", %{})
|> halt()
end
end

26. def call(conn, _opts %{}) do
authorization_headers = get_req_header(conn, "authorization")
case get_token(authorization_headers) do
{:ok, token} ->
case Auth.authenticate(token) do
{:ok, session: session, user: user} ->
conn
|> assign(:current_user, user)
|> assign(:current_session, session)
{:error, error} ->
conn
|> put_status(:unauthorized)
|> render(ErrorView, "401.json", %{})
|> halt()
end
{:error, error} ->
conn
|> put_status(:unauthorized)
|> render(ErrorView, "401.json", %{})
|> halt()
end
end

27. def call(conn, _opts %{}) do
authorization_headers = get_req_header(conn, "authorization")
case get_token(authorization_headers) do
{:ok, token} ->
case Auth.authenticate(token) do
{:ok, session: session, user: user} ->
conn
|> assign(:current_user, user)
|> assign(:current_session, session)
{:error, error} ->
conn
|> put_status(:unauthorized)
|> render(ErrorView, "401.json", %{})
|> halt()
end
{:error, error} ->
conn
|> put_status(:unauthorized)
|> render(ErrorView, "401.json", %{})
|> halt()
end
end

28. def call(conn, _opts %{}) do
authorization_headers = get_req_header(conn, "authorization")
case get_token(authorization_headers) do
{:ok, token} ->
case Auth.authenticate(token) do
{:ok, session: session, user: user} ->
conn
|> assign(:current_user, user)
|> assign(:current_session, session)
{:error, error} ->
conn
|> put_status(:unauthorized)
|> render(ErrorView, "401.json", %{})
|> halt()
end
{:error, error} ->
conn
|> put_status(:unauthorized)
|> render(ErrorView, "401.json", %{})
|> halt()
end
end

29. Please fix.
def call(conn, _opts %{}) do
authorization_headers = get_req_header(conn, "authorization")
case get_token(authorization_headers) do
{:ok, token} ->
case Auth.authenticate(token) do
{:ok, session: session, user: user} ->
conn
|> assign(:current_user, user)
|> assign(:current_session, session)
{:error, error} ->
conn
|> put_status(:unauthorized)
|> render(ErrorView, "401.json", %{})
|> halt()
end
{:error, error} ->
conn
|> put_status(:unauthorized)
|> render(ErrorView, "401.json", %{})
|> halt()
end
end

30. |>

31. def call(conn, _opts %{}) do
authorization_headers = get_req_header(conn, "authorization")
{:ok, token} = get_token(authorization_headers)
{:ok, session: session, user: user} = Auth.authenticate(token)
conn
|> assign(:current_user, user)
|> assign(:current_session, session)
end

32. def call(conn, _opts %{}) do
{:ok, session: session, user: user} =
conn
|> get_req_header("authorization")
|> get_token()
|> Auth.authenticate()
conn
|> assign(:current_user, user)
|> assign(:current_session, session)
end

33. def call(conn, _opts %{}) do
conn
|> get_req_header("authorization")
|> get_token()
|> Auth.authenticate()
|> handle_authentication(conn)
end

34. def call(conn, _opts %{}) do
conn
|> get_req_header("authorization")
|> get_token()
|> Auth.authenticate()
|> handle_authentication(conn)
end
def handle_authentication({:ok, session: session, user: user}, conn) do
conn
|> assign(:current_user, user)
|> assign(:current_session, session)
end

35. def call(conn, _opts %{}) do
conn
|> get_req_header("authorization")
|> get_token()
|> Auth.authenticate()
|> handle_authentication(conn)
end
def handle_authentication({:ok, session: session, user: user}, conn) do
conn
|> assign(:current_user, user)
|> assign(:current_session, session)
end
def handle_authentication({:error, error}, conn) do
conn
|> put_status(:unauthorized)
|> render(ErrorView, "401.json", %{})
|> halt()
end

36. def call(conn, _opts %{}) do
conn
|> get_req_header("authorization")
|> get_token()
|> Auth.authenticate()
|> handle_authentication(conn)
end
def handle_authentication({:ok, session: session, user: user}, conn) do
conn
|> assign(:current_user, user)
|> assign(:current_session, session)
end
def handle_authentication({:error, error}, conn) do
conn
|> put_status(:unauthorized)
|> render(ErrorView, "401.json", %{})
|> halt()
end

37. def call(conn, _opts %{}) do
conn
|> get_req_header("authorization")
|> get_token()
|> Auth.authenticate()
|> handle_authentication(conn)
end
def handle_authentication({:ok, session: session, user: user}, conn) do
conn
|> assign(:current_user, user)
|> assign(:current_session, session)
end
def handle_authentication({:error, error}, conn) do
conn
|> put_status(:unauthorized)
|> render(ErrorView, "401.json", %{})
|> halt()
end
{:ok, token}
@spec authenticate(String.t) :: …X

38. def call(conn, _opts %{}) do
conn
|> get_req_header("authorization")
|> get_token()
|> Auth.authenticate()
|> handle_authentication(conn)
end
def handle_authentication({:ok, session: session, user: user}, conn) do
conn
|> assign(:current_user, user)
|> assign(:current_session, session)
end
def handle_authentication({:error, error}, conn) do
conn
|> put_status(:unauthorized)
|> render(ErrorView, "401.json", %{})
|> halt()
end
@spec authenticate({:ok, String.t} | {:error, atom}) :: …
{:ok, token}
@spec authenticate(String.t) :: …X

39. def call(conn, _opts %{}) do
conn
|> get_req_header("authorization")
|> get_token()
|> Auth.authenticate()
|> handle_authentication(conn)
end
def handle_authentication({:ok, session: session, user: user}, conn) do
conn
|> assign(:current_user, user)
|> assign(:current_session, session)
end
def handle_authentication({:error, error}, conn) do
conn
|> put_status(:unauthorized)
|> render(ErrorView, "401.json", %{})
|> halt()
end
{:ok, token}
@spec authenticate(String.t) :: …X
@spec authenticate({:ok, String.t} | {:error, atom}) :: …Please fix.

40. 😕

41. 😯

42. def call(conn, _opts %{}) do
authorization_headers = get_req_header(conn, "authorization")
{:ok, token} = get_token(authorization_headers)
{:ok, session: session, user: user} = Auth.authenticate(token)
conn
|> assign(:current_user, user)
|> assign(:current_session, session)
end

43. def call(conn, _opts %{}) do
with authorization_headers <- get_req_header(conn, "authorization"),
{:ok, token} <- get_token(authorization_headers),
{:ok, session: session, user: user} <- Auth.authenticate(token)
conn
|> assign(:current_user, user)
|> assign(:current_session, session)
end

44. def call(conn, _opts %{}) do
with authorization_headers <- get_req_header(conn, "authorization"),
{:ok, token} <- get_token(authorization_headers),
{:ok, session: session, user: user} <- Auth.authenticate(token)
do
conn
|> assign(:current_user, user)
|> assign(:current_session, session)
end
end

45. def call(conn, _opts %{}) do
with authorization_headers <- get_req_header(conn, "authorization"),
{:ok, token} <- get_token(authorization_headers),
{:ok, session: session, user: user} <- Auth.authenticate(token)
do
conn
|> assign(:current_user, user)
|> assign(:current_session, session)
else
pattern -> instructions
pattern -> instructions
pattern -> instructions
end
end

46. def call(conn, _opts %{}) do
with authorization_headers <- get_req_header(conn, "authorization"),
{:ok, token} <- get_token(authorization_headers),
{:ok, session: session, user: user} <- Auth.authenticate(token)
do
conn
|> assign(:current_user, user)
|> assign(:current_session, session)
else
end
end

47. def call(conn, _opts %{}) do
with authorization_headers <- get_req_header(conn, "authorization"),
{:ok, token} <- get_token(authorization_headers),
{:ok, session: session, user: user} <- Auth.authenticate(token)
do
conn
|> assign(:current_user, user)
|> assign(:current_session, session)
else {:error, _reason} ->
conn
|> put_status(:unauthorized)
|> render(ErrorView, "401.json", %{})
|> halt()
end
end
👍

48. Scénario 2
Pagination

49. Scénario 2
GET ?page=0
[{…}, {…}, {…}, {…}]
Serveur Prestataire

50. Scénario 2
GET ?page=0
[{…}, {…}, {…}, {…}]
Serveur Prestataire
GET ?page=1
[{…}, {…}]

51. Scénario 2
GET ?page=0
[{…}, {…}, {…}, {…}]
Serveur Prestataire
GET ?page=1
[{…}, {…}]
GET ?page=2
[]

52. defmodule Client
def resources(page) do
...
end
end

53. [%{…}, %{…}, %{…}]
defmodule Client
def resources(page) do
...
end
end

54. def get_resources do
end

55. def get_resources do
page = 0
acc = []
end

56. def get_resources do
page = 0
acc = []
do
result = Client.resources(page)
page = page + 1
acc = acc ++ result
while(result != [])
acc
end

57. Récursivité

58. def get_resources do
end

59. def get_resources do
Client.resources(0)
end

60. def get_resources do
do_get_resources(0, Client.resources(0))
end

61. def get_resources do
do_get_resources(0, Client.resources(0))
end
defp do_get_resources(_page, []),
do: :ok

62. def get_resources do
do_get_resources(0, Client.resources(0))
end
defp do_get_resources(_page, []),
do: :ok
defp do_get_resources(page, resources),
do: do_get_resources(
page + 1,
Client.resources(page + 1)
)

63. def get_resources do
do_get_resources(0, Client.resources(0))
end
defp do_get_resources(_page, []),
do: :ok
defp do_get_resources(page, resources),
do: do_get_resources(
page + 1,
Client.resources(page + 1)
)

64. def get_resources do
do_get_resources([], 0, Client.resources(0))
end
defp do_get_resources(acc, _page, []),
do: acc
defp do_get_resources(acc, page, resources),
do: do_get_resources(
acc + resources,
page + 1,
Client.resources(page + 1)
)

65. def get_resources do
do_get_resources([], 0, Client.resources(0))
end
defp do_get_resources(acc, _page, []),
do: acc
defp do_get_resources(acc, page, resources),
do: do_get_resources(
acc + resources,
page + 1,
Client.resources(page + 1)
)

66. Utilisation

67. get_resources()
|> Enum.each(&process_resource/1)

68. get_resources()
|> Enum.each(&process_resource/1)

69. get_resources()
|> Enum.each(&process_resource/1)

70. get_resources()
|> Stream.each(&process_resource/1)
|> Stream.run()

71. get_resources()
|> Stream.each(&process_resource/1)
|> Stream.run()

72. get_resources()
|> Stream.each(&process_resource/1)
|> Stream.run()

73. get_resources()
|> Stream.each(&process_resource/1)
|> Stream.run()

74. def get_resources do
end

75. def get_resources do
Stream.unfold()
end

76. unfold(initial_acc, (acc -> {element, acc} | nil))

77. def get_resources do
Stream.unfold()
end

78. def get_resources do
Stream.unfold(0, fn page ->
end)
end

79. def get_resources do
Stream.unfold(0, fn page ->
resources = Client.resources(page)
{resources, page + 1}
end)
end

80. def get_resources do
Stream.unfold(0, fn page ->
case Client.resources(page) do
[] -> nil
resources -> {resources, page + 1}
end
end)
end

81. get_resources |> Enum.to_list()
[
[ %{id: 1, …}, %{id: 2, …}, %{id: 3, …} ],
[ %{id: 4, …}, %{id: 5, …}, %{id: 6, …} ],
[ %{id: 7, …}, %{id: 8, …}, %{id: 9, …} ]
]
iex>

82. def get_resources do
Stream.unfold(0, fn page ->
case Client.resources(page) do
[] -> nil
resources -> {resources, page + 1}
end
end)
end

83. def get_resources do
Stream.unfold(0, fn page ->
case Client.resources(page) do
[] -> nil
resources -> {resources, page + 1}
end
end)
|> Stream.flat_map(& &1)
end

84. [
%{id: 1, …}, %{id: 2, …}, %{id: 3, …},
%{id: 4, …}, %{id: 5, …}, %{id: 6, …},
%{id: 7, …}, %{id: 8, …}, %{id: 9, …}
]
get_resources |> Enum.to_list()iex>

85. 👍def get_resources do
Stream.unfold(0, fn page ->
case Client.resources(page) do
[] -> nil
resources -> {resources, page + 1}
end
end)
|> Stream.flat_map(& &1)
end

86. Intégration
et livraison continues
Retour d’expérience

91. .gitlab-ci.yml

92. image: elixir:1.5.1
services:
- postgres:9.6
variables:
MIX_ENV: test
stages:
- build
- test
- package
- deploy
before_script:
- mix local.hex --force
- mix local.rebar --force
- mix deps.get --only test
cache:
paths:
- "_build"
- "deps"
.gitlab-ci.yml

93. image: elixir:1.5.1
services:
- postgres:9.6
variables:
MIX_ENV: test
stages:
- build
- test
- package
- deploy
before_script:
- mix local.hex --force
- mix local.rebar --force
- mix deps.get --only test
cache:
paths:
- "_build"
- "deps"
.gitlab-ci.yml

94. image: elixir:1.5.1
services:
- postgres:9.6
variables:
MIX_ENV: test
stages:
- build
- test
- package
- deploy
before_script:
- mix local.hex --force
- mix local.rebar --force
- mix deps.get --only test
cache:
paths:
- "_build"
- "deps"
.gitlab-ci.yml

95. image: elixir:1.5.1
services:
- postgres:9.6
variables:
MIX_ENV: test
stages:
- build
- test
- package
- deploy
before_script:
- mix local.hex --force
- mix local.rebar --force
- mix deps.get --only test
cache:
paths:
- "_build"
- "deps"
.gitlab-ci.yml

96. build:
stage: build
script:
- mix compile
doc:
stage: build
script:
- mix docs
.gitlab-ci.yml

97. .gitlab-ci.yml
lint:
stage: test
script:
- mix credo
- mix dialyzer --halt-exit-status
migrations:
stage: test
script:
- mix ecto.reset
- mix ecto.rollback --all
test:
stage: test
script:
- mix ecto.reset
- mix test

98. .gitlab-ci.yml
lint:
stage: test
script:
- mix credo
- mix dialyzer --halt-exit-status
migrations:
stage: test
script:
- mix ecto.reset
- mix ecto.rollback --all
test:
stage: test
script:
- mix ecto.reset
- mix test

99. .gitlab-ci.yml
lint:
stage: test
script:
- mix credo
- mix dialyzer --halt-exit-status
migrations:
stage: test
script:
- mix ecto.reset
- mix ecto.rollback --all
test:
stage: test
script:
- mix ecto.reset
- mix test

100. .gitlab-ci.yml
lint:
stage: test
script:
- mix credo
- mix dialyzer --halt-exit-status
migrations:
stage: test
script:
- mix ecto.reset
- mix ecto.rollback --all
test:
stage: test
script:
- mix ecto.reset
- mix test

101. .gitlab-ci.yml
package:
stage: package
script:
- bin/package.sh
artifacts:
expire_in: 1 month
paths:
- artifact/

102. .gitlab-ci.yml
package:
stage: package
script:
- bin/package.sh
artifacts:
expire_in: 1 month
paths:
- artifact/

103. .gitlab-ci.yml
deploy:integration:
stage: deploy
environment:
name: $CI_BUILD_REF_NAME
url: https://$CI_BUILD_REF_NAME.integration
only:
- master@trustbk/backend
script:
- bin/deploy.sh

104. .gitlab-ci.yml
deploy:integration:
stage: deploy
environment:
name: $CI_BUILD_REF_NAME
url: https://$CI_BUILD_REF_NAME.integration
only:
- master@trustbk/backend
script:
- bin/deploy.sh

105. .gitlab-ci.yml
deploy:integration:
stage: deploy
environment:
name: $CI_BUILD_REF_NAME
url: https://$CI_BUILD_REF_NAME.integration
only:
- master@trustbk/backend
script:
- bin/deploy.sh

106. bin/package.sh

107. bin/package.sh
distillery
A pure Elixir implementation of
release packaging functionality for the Erlang VM.

108. rel/config.exs
Path.join(["rel", "plugins", "*.exs"])
|> Path.wildcard()
|> Enum.map(&Code.eval_file(&1))
use Mix.Releases.Config,
default_release: :backend,
default_environment: Mix.env()
environment :prod do
set include_erts: true
set include_src: false
set include_system_libs: true
end
release :backend do
set version: current_version(:backend)
set applications: [
:backend,
…
]
end

109. bin/package.sh
$ mix release
==> Assembling release..
==> Building release backend:0.0.1 using environment prod
==> Including ERTS 9.0.4 from /usr/local/Cellar/erlang/20.0/lib/erlang/erts-9.0.4
==> Packaging release..
==> Release successfully built!
You can run it in one of the following ways:
Interactive: _build/prod/rel/backend/bin/backend console
Foreground: _build/prod/rel/backend/bin/backend foreground
Daemon: _build/prod/rel/backend/bin/backend start

110. bin/package.sh
_build/prod/rel/backend/releases/0.0.1/backend.tar.gz

111. bin/package.sh
$ tree -L 2 _build/prod/rel/backend
_build/prod/rel/backend
├── bin
│ ├── backend
│ ├── backend.bat
│ ├── backend_loader.sh
│ ├── release_utils.escript
│ └── start_clean.boot
├── erts-9.0
│ ├── bin
│ ├── include
│ ├── lib
│ └── src
├── lib
│ ├── backend-0.0.1
│ └── […dependencies…]
├── releases
│ ├── 0.0.1
│ ├── RELEASES
│ └── start_erl.data
└── var
├── WARNING_README
├── log
├── sys.config
└── vm.args
bin/backend start
bin/backend stop

112. bin/package.sh
#!/bin/bash -ex
MIX_ENV=prod mix release —warnings-as-errors
[…preparing a tarball from _build/prod/rel/backend]

113. bin/package.sh
#!/bin/bash -ex
MIX_ENV=prod mix release —warnings-as-errors
[…preparing a tarball from _build/prod/rel/backend]

114. bin/package.sh

115. lib/backend/release_tasks.ex
defmodule Elixir.Backend.ReleaseTasks do
alias Backend.Repo
alias Ecto.Migrator
@start_apps [:ecto, :postgrex]
def migrate do
:ok = Application.load(:backend)
Enum.each(@start_apps, &Application.ensure_all_started/1)
{:ok, _} = Repo.start_link(pool_size: 1)
path = Application.app_dir(:backend, "priv/repo/migrations")
Migrator.run(Repo, path, :up, all: true)
Enum.each(@start_apps, &Application.stop/1)
:init.stop()
end
end

116. lib/backend/release_tasks.ex
defmodule Elixir.Backend.ReleaseTasks do
alias Backend.Repo
alias Ecto.Migrator
@start_apps [:ecto, :postgrex]
def migrate do
:ok = Application.load(:backend)
Enum.each(@start_apps, &Application.ensure_all_started/1)
{:ok, _} = Repo.start_link(pool_size: 1)
path = Application.app_dir(:backend, "priv/repo/migrations")
Migrator.run(Repo, path, :up, all: true)
Enum.each(@start_apps, &Application.stop/1)
:init.stop()
end
end

117. lib/backend/release_tasks.ex
defmodule Elixir.Backend.ReleaseTasks do
alias Backend.Repo
alias Ecto.Migrator
@start_apps [:ecto, :postgrex]
def migrate do
:ok = Application.load(:backend)
Enum.each(@start_apps, &Application.ensure_all_started/1)
{:ok, _} = Repo.start_link(pool_size: 1)
path = Application.app_dir(:backend, "priv/repo/migrations")
Migrator.run(Repo, path, :up, all: true)
Enum.each(@start_apps, &Application.stop/1)
:init.stop()
end
end

118. rel/commands/migrate.sh
#!/bin/sh
bin/backend command Elixir.Backend.ReleaseTasks migrate

119. rel/config.exs
release :backend do
set version: current_version(:backend)
set applications: [
:backend,
…
]
set commands: [
"migrate": "rel/commands/migrate.sh"
]
end

120. bin/deploy.sh

121. config/prod.exs
use Mix.Config
config :backend, Backend.Repo,
adapter: Ecto.Adapters.Postgres,
username: System.get_env("TBK_BACKEND_DB_USER"),
password: System.get_env("TBK_BACKEND_DB_PASSWORD"),
database: System.get_env("TBK_BACKEND_DB_DATABASE"),
hostname: System.get_env("TBK_BACKEND_DB_HOSTNAME"),
pool_size: 10
Evaluated at compile-time!

122. config/prod.exs
use Mix.Config
config :backend, Backend.Repo,
adapter: Ecto.Adapters.Postgres,
username: "${TBK_BACKEND_DB_USER}",
password: "${TBK_BACKEND_DB_PASSWORD}",
database: "${TBK_BACKEND_DB_DATABASE}",
hostname: "${TBK_BACKEND_DB_HOSTNAME}",
pool_size: 10
Evaluated at runtime by Erlang VM with REPLACE_OS_VARS=true

123. bin/deploy.sh
[…copy tarball to server by SSH]
[…expand]
vcour/bin/backend stop
ln -sfT versions/20170921102241_8f41acc1 vcour
vcour/bin/backend migrate
vcour/bin/backend start

124. • Idempotent
• Stateless
• Zero-downtime deployment
bin/deploy.sh

126. Questions
Joan Zapata
@joanzap
Raphaël Lustin
@raphilustin