Introdução ao Docker até a criação de ambientes imutáveis com docker-compose. --- Docker introduction until immutable environments with docker-compose. Language: PT-BR

1. Docker 101 e Ambientes
imutáveis

2. Workshop
Qual o nosso propósito com o workshop?
- Docker 101?
- Ambientes imutáveis?

3. Wallison Marra
- Em 2006 iniciei meu caminho pelo mundo da web.
- DevOps Engineer na Hotmart.
- Entusiasta da tecnologia.
- Games, família e uma boa cerveja.

4. Docker 101

5. Preload
Hoje vivenciamos o uso do Docker graças a 2 peças fundamentais:
- LXC (Um conjunto de ferramentas do linux)
- DotCloud (Uma empresa)

6. LXC
LinuX Container
É um conjunto de ferramentas, bibliotecas, templates e controladores de
linguagem que nos permite criar e controlar sistemas ou aplicações em container.

7. LXC
Okay, but what is container?
Linux Container é considerado algo entre o chroot e uma máquina virtual
propriamente dita, e neste meio é onde conseguimos criar "ambientes virtuais"
(containers) sem a necessidade de um novo kernel.
linuxcontainers.org/lxc

8. E a DotCloud?
DotCloud é uma empresa que possuía vários projetos open source em LXC, e o
Docker era um destes projetos.

9. DotCloud
Docker se tornou tão popular que a empresa DotCloud decidiu mudar o nome da
empresa para Docker.

10. Docker
Docker vem dominando o mercado de conteinerização desde seu surgimento, e
hoje possui várias comunidades além de vários eventos pelo mundo.
https://www.docker.com/community/events

11. Docker
- Hoje é utilizado por desenvolvedores para criação de ambiente imutáveis
evitando a frase "Na minha máquina funciona!".
- Utilizado por DevOps para gerenciamento de aplicações de ponta-a-ponta
isolando processos, adquirindo performance computacional.

12. Docker vs Virtual Machine

13. E os containers?

16. Containers
São os pequenos "blocos" utilizados para executar tarefas específicas e não mais
que isso.
Redis
MySQLPHP
Nginx
HOST

17. The fluxo

19. Docker 101
Hello World!

20. Container Exemplo

21. Container Exemplo

22. O que foi feito?
$ docker run hello-world
- docker
- run (utilizando para criar e executar um container)
- hello-world (imagem a ser utilizada para a criação do container)

23. Terminal

24. Como acessar o terminal?

25. O que foi feito?
$ docker run -ti ubuntu bash
- docker (executável)
- run (utilizando para criar e executar um container)
- -ti (-t abre terminal no container e -i mantém o terminal interativo)
- ubuntu (imagem utilizada para criar o container)
- bash (comando a ser executado pelo container - bash mantém o terminal
aberto)

26. $ docker run -i ubuntu bash
$ docker run -t ubuntu bash
Testing...

27. Listando imagens
$ docker images

28. Listando containers
$ docker ps

29. Listando containers
$ docker ps -a (all)

31. Hands On!

32. $ docker run -ti -p 8080:80 ubuntu:16.04 bash
Interagindo com containers

33. Interagindo com containers
$ apt-get install nano

34. $ apt-get update
Interagindo com containers

35. Interagindo com containers
$ apt-get install nginx
$ service nginx start

36. Interagindo com containers

37. O que ocorreu?
$ docker run -ti -p 8080:80 ubuntu:16.04 bash
- docker (deamon docker)
- run (utilizando para criar e executar um container)
- -ti (-t abre terminal no container e -i mantém o terminal interativo)
- -p 8080:80 (Expõe porta do container baseado em uma porta do host)
- 8080 (porta do host)
- 80 (porta do container)
- ubuntu:16.04 (Imagem utilizada para criar o container)
- bash (comando a ser executado quando o container for iniciado)
Interagindo com containers

38. Interagindo com containers
Mas meu terminal tem que ficar aberto pra sempre?

39. Com a tela do terminal aberto pressione a tecla control e aperte p + q.
$ docker ps
$ docker attach bed7185d03bb (ID do container)
Interagindo com containers

40. Crie o arquivo index.html
- Conteúdo: <h1>Hello Docker</h1>
$ docker pull nginx:alpine
Interagindo com containers

41. $ docker run --name web-server
-p 8080:80
-v `pwd`:/usr/share/nginx/html
-d nginx:alpine
Interagindo com containers

42. Interagindo com containers

43. $ docker run --name web-server -p 8080:80
-v `pwd`:/usr/share/nginx/html: -d nginx:alpine
- docker (daemon)
- --name webserver (concede um nome para o container)
- -v `pwd`:/usr/share/nginx/html (baseado em um diretório do host, cria um
volume no container)
- -d (executa o container em background e informa seu ID)
- nginx:alpine (nome da imagem utilizada para criar o container)
O que ocorreu?

44. Docker 101
Imagens de Containers

45. Imagens de Containers
Para cada serviço a ser utilizado, e para cada versão de uma aplicação,
possuímos uma imagem.
jenkins-2.58 jenkins-2.57
jenkins-2.56 jenkins-2.46.2

46. Dockerfile
Arquivo utilizado para criar imagens para containers em Docker. Local onde
iremos informar o que nosso container deve possuir, além de:
- Instalar pacotes e bibliotecas.
- Criar variáveis de ambiente.
- Expor portas.
- Copiar arquivos.
- Configurar comando base do container.
- Etc...

47. Gerando uma imagem
Crie um arquivo chamado Dockerfile na mesma pasta do arquivo index.html que
criamos anteriormente.
$ docker build -t web-app:1.0 .
$ docker run -d -p 8080:80 web-app:1.0

48. Gerando uma imagem

49. Gerando uma imagem
Edite o arquivo index.html e insira a linha <h2>V2</h2>.
$ docker build -t web-app:2.0 .
$ docker run -d -p 8080:80 web-app:2.0

50. Gerando uma imagem
$ docker images

52. E pra onde mando minhas imagens?

53. Repositório de imagens
hub.docker.com (ou store.docker.com)

54. Publicando imagens
$ docker tag web-app:1.0 repo_name/web-app:1.0
- docker
- tag (adiciona tag a uma imagem)
- web-app:1.0 (nome da imagem a ser adicionado uma tag)
- repo_name/web-app:1.0 (nome da tag a ser adicionada)

55. $ docker images
Publicando imagens

56. $ docker push wmarra/web-app:1.0
Publicando imagens

57. $ docker login
$ docker push wmarra/web-app:1.0
Publicando imagens

58. hub.docker.com

59. Docker 101 done!

60. Docker
Ambientes Imutáveis

61. Ambientes imutáveis
São ambientes que não sofrem alterações, mesmo quando executados em outros
computadores.
- Configurações idênticas.
- Ambiente portável
- Deploy em minutos, e até em segundos.

62. Ambientes imutáveis
Redis
MySQLPHP
Nginx
PC01
Redis
MySQLPHP
Nginx
PC02

63. Ambientes imutáveis
Com estes ambientes ganhamos segurança, e agilidade no processo de
desenvolvimento de aplicações.
- Segurança: ambientes idênticos.
- A frase: "Na minha máquina funciona", deixa de existir.
- Ambiente de desenvolvimento = produção
- Agilidade: automatização de processos.

64. Ambientes imutáveis
Starting…
$ git clone git@github.com:wmarra/in-moment-docker-frontend.git
$ git checkout develop
$ git clone git@github.com:wmarra/in-moment-docker-backend.git
$ git checkout develop

65. $ cd in-moment-docker-frontend/
Ambientes imutáveis

66. $ docker build -t frontapp .
Ambientes imutáveis

67. $ docker run -d
-v `pwd`:/usr/share/nginx/html
-p 8080:80 frontapp
- -v `pwd`:/usr/share/nginx/html
(cria um volume no container com o conteúdo da pasta
/Users/marra/Projects/in-moment-docker-frontend do host dentro de
/usr/share/nginx/html no container)
Ambientes imutáveis

68. Caso tenha problemas com a interface do frontend, execute o comando abaixo:
$ docker exec container_id npm install
Ambientes imutáveis

69. Ambientes imutáveis

70. $ cd in-moment-docker-backend/
Ambientes imutáveis

71. $ docker build -t backapp .
Ambientes imutáveis

72. $ docker run -d
-v `pwd`:/usr/src/app
-p 3000:3000 backapp sh -c 'npm install && npm start'
- sh -c 'npm install && npm start' (sh -c executa um comando shell dentro do
container)
E por que não "...backapp npm install && npm start"?
Ambientes imutáveis

73. Ambientes imutáveis

74. Ambientes imutáveis
Front-end, back-end…. e o banco de dados?

75. Calma, estamos quase lá…
$ docker run -d -p 3306:3306 --name dbapp wmarra/in-moment-dbapp
Ambientes imutáveis

76. Pronto, temos nossos 3 containers =]
Ambientes imutáveis
FRONTAPP BACKAPP DBAPP

77. Mas não se comunicam ainda =[
Ambientes imutáveis

78. Docker
Ambientes Imutáveis
Linkando Containers

79. Preparando nosso ambiente:
$ cd in-moment-docker-backend && git checkout master
$ cd in-moment-docker-frontend && git checkout master
$ docker rm -f $(docker ps -aq) - (remove todos os containers ativos e inativos)
Ambientes imutáveis

80. $ docker run -d --name dbapp -p 3306:3306 wmarra/in-moment-dbapp
$ cd in-moment-docker-backend
$ docker run -i --name backapp_dbapp
--link dbapp:mysql -d -p 3000:3000
-v `pwd`:/usr/src/app
backapp sh -c 'npm install && npm start'
Ambientes imutáveis

81. Quando os containers estão linkados eles se conectam em um rede própria, e se
comunicam pelos seus nomes.
--link dbapp:mysql (dbapp é o nome do container e o outro mysql é o apelido do
container a ser visível quando for linkado)
Ambientes imutáveis
Network
BACKAPP DBAPP
Mysql

82. Ambientes imutáveis

83. Ambientes imutáveis

84. Ambientes imutáveis
Para completar, vamos iniciar nosso frontend:
$ cd in-moment-docker-frontend/
$ git checkout master
$ docker run -d -p 8080:80 -v `pwd`:/usr/share/nginx/html frontapp

85. Ambientes imutáveis

86. Ambientes imutáveis
E como orquestrar um ambiente com docker?
- Docker Compose

87. Docker compose é utilizado para orquestrar container de maneira simples.
Com ele conseguimos fazer todos os passos mostrados anteriormente, facilitando
e muito nossa vida.
Ambientes imutáveis

88. $ docker rm -f $(docker ps -aq)
- docker
- rm -f (rm remove um container, -f força a remoção)
- $(docker ps -aq) (ps lista os containers, -a lista all containers e -q retorna o
id de all containers)
$ docker rmi -f $(docker images)
- docker
- rmi -f (força a remoção de todas as imagens)
- $(docker images) (lista todas imagens disponíveis)
Ambientes imutáveis

89. $ cd in-moment-docker-backend/
$ mv docker-compose.yml ../
Ambientes imutáveis

90. Ambientes imutáveis

91. O que fizemos?
- version (versão do docker-compose a ser utilizado)
- services (declaração dos serviço - containers).
- container_name (nome do container)
- image (imagem a ser utilizada para criar o container)
- ports (mapeamento de portas)
- links (quais containers serão linkados entre si)
- depends_on (dependência de container)
- command (comando a ser executado pelo container)
Ambientes imutáveis

92. $ docker-compose up --build
…
Ambientes imutáveis

93. O que fizemos?
$ docker-compose up --build
- docker-compose (docker-compose command)
- up (cria todo o ambiente configurado do docker-compose.yml)
- --build (builda ou rebuild as imagens do docker-compose.yml)
Ambientes imutáveis

94. $ docker-compose ps
Ambientes imutáveis

95. Ambientes imutáveis

96. Ambientes imutáveis

97. E assim garantimos nossos ambientes imutáveis!
Ambientes imutáveis

98. Vlws!

99. Dúvidas?

100. www.docker.com
hub.docker.com
https://www.youtube.com/user/linuxtipscanal
Referências