Docker 101 e Ambientes Imutáveis

Docker 101 e Ambientes
imutáveis

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

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.

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

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.

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

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

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

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

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.

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

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)

O que foi feito?
$ docker run -ti ubuntu bash
- docker (executável)
- -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)

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

Listando imagens
$ docker images

Listando containers
$ docker ps

Listando containers
$ docker ps -a (all)

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

$ apt-get install nano

$ apt-get update

$ apt-get install nginx
$ service nginx start

O que ocorreu?
$ docker run -ti -p 8080:80 ubuntu:16.04 bash
- docker (deamon docker)
- -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)

Mas meu terminal tem que ficar aberto pra sempre?

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

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

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

$ 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?

Docker 101
Imagens de Containers

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

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...

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

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

Gerando uma imagem
$ docker images

E pra onde mando minhas imagens?

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

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)

$ docker images
Publicando imagens

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

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

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.

Redis
MySQLPHP
Nginx
PC01
Redis
MySQLPHP
Nginx
PC02

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.

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

$ cd in-moment-docker-frontend/

$ docker build -t frontapp .

$ 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)

Caso tenha problemas com a interface do frontend, execute o comando abaixo:
$ docker exec container_id npm install

$ cd in-moment-docker-backend/

$ docker build -t backapp .

$ 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"?

Front-end, back-end…. e o banco de dados?

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

Pronto, temos nossos 3 containers =]
FRONTAPP BACKAPP DBAPP

Mas não se comunicam ainda =[

Docker
Ambientes Imutáveis
Linkando Containers

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)

$ 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'

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)
Network
BACKAPP DBAPP
Mysql

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

E como orquestrar um ambiente com docker?
- Docker Compose

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

$ 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)

$ cd in-moment-docker-backend/
$ mv docker-compose.yml ../

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)

$ docker-compose up --build
…

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)

$ docker-compose ps

E assim garantimos nossos ambientes imutáveis!

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

Docker 101 e Ambientes Imutáveis

Mais conteúdo relacionado

Mais procurados

Semelhante a Docker 101 e Ambientes Imutáveis

Docker 101 e Ambientes Imutáveis