Dominando o Docker - One Bit Code

Introdução

O Docker é um plataforma (aberta) que permite que você crie, rode e faça deploy de containers. De maneira simples, um container é o empacotamento da sua aplicação mais as dependências dela.

Por exemplo, se você quiser utilizar um Container que possua todas as dependências do Ruby On Rails já instalados sem que você instale essas dependências diretamente na sua máquina, você pode fazer isso com poucos comandos de maneira completamente isolada do seu sistema.

Você também pode criar suas próprias imagens personalizadas para gerar seus containers e depois distribuí-las para os outros programadores da sua equipe poderem trabalhar em um ambiente idêntico ao seu, ou seja, em poucos minutos a máquina de qualquer desenvolvedor novo da sua equipe vai estar preparada pra ele começar a trabalhar.

Porque Docker?

A primeira resposta que vem a minha mente é simples, porque você merece ser feliz. Seu tempo é valioso e você não vai querer gastar ainda mais horas do que já gastou na vida configurando máquinas iguais sempre que muda de ambiente de desenvolvimento ou servidor. O Docker vai te ajudar a automatizar e ainda mais, a melhorar todo esse processo e evitar o velho e bom “Na minha máquina estava funcionando, não sei o que houve”.

O que vamos Aprender?

Como gerenciar nossos containers usando o Docker (3 exemplos)
Como dockerizar um Projeto Rails usando Docker-Compose

Também vamos ver uma lista com os comandos mais usados do Docker e do Docker Compose para facilitar sua vida 🙂

Links falados no Screencast:

Como instalar o Docker: https://docs.docker.com/engine/installation/
Como instalar o Docker Compose https://docs.docker.com/compose/
Docker Hub https://hub.docker.com/
Documentação do Docker https://docs.docker.com/

Ingredientes:

Docker
Docker Compose
Ruby On Rails
PostgreSQL

PARTE 1 – Criando um container com o Ubuntu

Nesta parte do Screencast nós criamos um container com o Ubuntu dentro onde nós tivemos acesso ao terminal dele, é um bom exemplo para você começar a entender como os ambientes são isolados.

Para gerar o seu container através da imagem padrão do ubuntu, rode:

JavaScript

docker run -t -i ubuntu /bin/bash

1

docker run -t -i ubuntu /bin/bash
Para verificar que o container esta no ar, em outro console rode:

JavaScript

docker ps

1

docker ps
Para parar o seu container, pegue o Id do seu container que apareceu depois do comando anterior e rode o seguinte comando:

JavaScript

docker stop id_do_seu_container

1

docker stop id_do_seu_container
Agora que seu container está parado, você pode rodar o seguinte comando para listá-lo (junto com todos os outros parados):

JavaScript

docker ps -a

1

docker ps -a
Para que seu container parado volte a rodar, pegue novamente o id dele e rode o seguinte comando:

JavaScript

docker start id_do_seu_container

1

docker start id_do_seu_container
Para que você possa voltar a ver o bash do seu container ou rodar outro comando, pegue novamente o id e rode:

JavaScript

docker exec -it id_do_seu_container bash

1

docker exec -it id_do_seu_container bash
Agora para finalizar para novamente seu container rodando:

JavaScript

docker stop id_do_seu_container

1

docker stop id_do_seu_container
E apague ele (se você não for usar seu container é uma boa prática que você apague ele para liberar memória), rode:

JavaScript

docker rm id_do_seu_container

1

docker rm id_do_seu_container

PARTE 2 – Criando e subindo um Projeto Rails via Docker

Aqui vimos no Screencast como criar um projeto Rails sem ter o rails instalado na nossa máquina (usando um container que possui o Rails), como criar um Dockerfile para gerar uma imagem personalizada e como subir nosso serviço Rails via Container.

Crie seu projeto Rails rodando:

JavaScript

docker run -it --rm --user "$(id -u):$(id -g)" -v "$PWD":/usr/src/app -w /usr/src/app rails rails new --skip-bundle my_awesome_app

1

docker run -it --rm --user "$(id -u):$(id -g)" -v "$PWD":/usr/src/app -w /usr/src/app rails rails new --skip-bundle my_awesome_app

Agora entre no diretório via console e crie um file chama “Dockerfile” e substitua o conteúdo dele por:

FROM ruby:2.3

RUN mkdir -p /usr/src/app
WORKDIR /usr/src/app

RUN apt-get update &amp;&amp; apt-get install -y nodejs --no-install-recommends &amp;&amp; rm -rf /var/lib/apt/lists/*
RUN apt-get update &amp;&amp; apt-get install -y sqlite3 --no-install-recommends &amp;&amp; rm -rf /var/lib/apt/lists/*

COPY Gemfile /usr/src/app/

RUN bundle install

COPY . /usr/src/app

EXPOSE 3000
CMD puma -C config/puma.rb

FROM ruby:2.3

RUN mkdir -p /usr/src/app

WORKDIR /usr/src/app

RUN apt-get update && apt-get install -y nodejs --no-install-recommends && rm -rf /var/lib/apt/lists/*

RUN apt-get update && apt-get install -y sqlite3 --no-install-recommends && rm -rf /var/lib/apt/lists/*

COPY Gemfile /usr/src/app/

RUN bundle install

COPY . /usr/src/app

EXPOSE 3000

CMD puma -C config/puma.rb

Agora que criamos nosso Dockerfile podemos fazer o Build da nossa imagem (Construir nossa imagem personalizada), dentro da pasta do seu projeto rode:

JavaScript

docker build -t my_awesome_app .

1

docker build -t my_awesome_app .
Depois disso podemos pegar a imagem que geramos e criar nosso container para subir nossa aplicação, no seu console rode:

JavaScript

docker run -v "$PWD":/usr/src/app -p 3000:3000 my_awesome_app

1

docker run -v "$PWD":/usr/src/app -p 3000:3000 my_awesome_app

*Mais detalhes sobre os comandos no Screencast
Pronto \o/, agora acesse no seu Browser http://localhost:3000

PARTE 3 – Criando e subindo um Projeto Rails via Docker + PostgreSQL + Network

Novamente nesta parte nós subimos um servidor Rails, porém dessa vez vamos usar também um container com o PostgreSQL (Banco de Dados) e vamos usar um network do docker para ligar tudo isto 🙂

Crie seu projeto Rails rodando:

JavaScript

docker run -it --rm --user "$(id -u):$(id -g)" -v "$PWD":/usr/src/app -w /usr/src/app rails rails new --skip-bundle my_awesome_app2

1

docker run -it --rm --user "$(id -u):$(id -g)" -v "$PWD":/usr/src/app -w /usr/src/app rails rails new --skip-bundle my_awesome_app2

Agora entre no diretório via console e crie um file chamado “Dockerfile” e substitua o conteúdo dele por:

FROM ruby:2.3

RUN mkdir -p /usr/src/app
WORKDIR /usr/src/app

RUN apt-get update &amp;&amp; apt-get install -y nodejs --no-install-recommends &amp;&amp; rm -rf /var/lib/apt/lists/*
RUN apt-get update &amp;&amp; apt-get install -y postgresql-client --no-install-recommends &amp;&amp; rm -rf /var/lib/apt/lists/*

COPY Gemfile /usr/src/app/

RUN bundle install

COPY . /usr/src/app

EXPOSE 3000
CMD puma -C config/puma.rb

FROM ruby:2.3

RUN mkdir -p /usr/src/app

WORKDIR /usr/src/app

RUN apt-get update && apt-get install -y nodejs --no-install-recommends && rm -rf /var/lib/apt/lists/*

RUN apt-get update && apt-get install -y postgresql-client --no-install-recommends && rm -rf /var/lib/apt/lists/*

COPY Gemfile /usr/src/app/

RUN bundle install

COPY . /usr/src/app

EXPOSE 3000

CMD puma -C config/puma.rb

Agora que criamos nosso Dockerfile podemos fazer o Build da nossa imagem (Construir nossa imagem personalizada), dentro da pasta do seu projeto rode:

JavaScript

docker build -t my_custom_image_2 .

1

docker build -t my_custom_image_2 .
Nós precisamos criar agora uma network (uma rede interna do docker que vai conectar nossos containers para que um possa acessar o outro livremente), no seu console rode:

JavaScript

docker network create my_awesome_network

1

docker network create my_awesome_network
Agora vamos subir um container com o PostgreSQL dentro, rode:

JavaScript

docker run --name db -d --network=my_awesome_network postgres

1

docker run --name db -d --network=my_awesome_network postgres

Para que o nosso APP Rails se conecte ao PostgreSQL disponível nós precisamos editar o arquivo ‘/config/database.yml’, do nosso projeto, neste arquivo substitua o conteúdo por:

default: &amp;default
  adapter: postgresql
  encoding: unicode
  pool: &lt;%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %&gt;
  # Apenas acrescentamos o nosso container como Host
  host: db
  # E colocamos o usuário default do postgreSQL
  user: postgres

development:

default: &default

adapter: postgresql

encoding: unicode

pool: <%= ENV.fetch("RAILS_MAX_THREADS") { 5 } %>

# Apenas acrescentamos o nosso container como Host

host: db

# E colocamos o usuário default do postgreSQL

user: postgres

development:

Agora nós precisamos criar o banco de dados, rode:

JavaScript

docker run -v "$PWD":/usr/src/app --network=my_awesome_network my_custom_image_2 rake db:create

1

docker run -v "$PWD":/usr/src/app --network=my_awesome_network my_custom_image_2 rake db:create
E subir nosso servidor:

JavaScript

docker run -v "$PWD":/usr/src/app -p 3000:3000 --network=my_awesome_network my_custom_image_2

1

docker run -v "$PWD":/usr/src/app -p 3000:3000 --network=my_awesome_network my_custom_image_2

PARTE 4 – Usando o Docker Compose para organizar nossos containers

Agora sim entramos no modo de uso do Docker que eu acho mais útil, via docker compose. O Docker Compose é uma ferramenta para orquestrar todos os nossos containers (Vai nos ajudar a subir eles juntos, vai gerar uma network e vai nos permitir gerenciar melhor nossos volumes).

No mesmo projeto que trabalhamos na Parte 3 (Apenas para reaproveitar o trabalho) vamos criar um arquivo chamado “docker-compose.yml” e ele vai gerenciar nossos containers para gente. Crie o arquivo e coloque o seguinte conteúdo dentro dele:

version: '2'

services:
  db:
    image: 'postgres:9.5'
    volumes:
      - 'postgres:/var/lib/postgresql/data'

  website:
    depends_on:
      - 'db'
    build: .
    ports:
      - '3000:3000'
    volumes:
      - '.:/usr/src/app'

volumes:
  postgres:

version: '2'

services:

db:

image: 'postgres:9.5'

volumes:

- 'postgres:/var/lib/postgresql/data'

website:

depends_on:

- 'db'

build: .

ports:

- '3000:3000'

volumes:

- '.:/usr/src/app'

volumes:

postgres:

* Explicações sobre esse arquivo no Screencast

Para fazer o Build de todos os nossos containers basta rodar (dentro do projeto):

JavaScript

docker-compose build

1

docker-compose build
Agora como nós criamos um novo container para o PostgreSQL nós precisamos criar nosso banco de dados de novo, porém agora vamos usar os comandos do docker-compose para fazer isso de maneira fácil. No console rode:

JavaScript

docker-compose run website rake db:create

1

docker-compose run website rake db:create
Para subir nossos containers, rode no console:

JavaScript

docker-compose up

1

docker-compose up

Comandos do Docker (Lista de comandos úteis)

Gera um container e roda um comando dentro:

JavaScript

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]

1

docker run [OPTIONS] IMAGE [COMMAND] [ARG...]
Visualiza os containers rodando:

JavaScript

docker ps

1

docker ps
Visualizando todos os containers:

JavaScript

docker ps -a

1

docker ps -a
Parando um container:

JavaScript

docker stop id_do_container

1

docker stop id_do_container
Parando TODOS os containers que estão rodando:

JavaScript

docker stop $(docker ps -a -q)

1

docker stop $(docker ps -a -q)
Dando um start em um container parado:

JavaScript

docker start id_do_container

1

docker start id_do_container
Apagando um container:

JavaScript

docker rm id_do_container

1

docker rm id_do_container
Apagando TODOS os containers:

JavaScript

docker rm $(docker ps -a -q)

1

docker rm $(docker ps -a -q)
Executando um comando dentro de um container que já está rodando:

JavaScript

docker exec [OPTIONS] CONTAINER COMMAND [ARG...]

1

docker exec [OPTIONS] CONTAINER COMMAND [ARG...]
Vendo as imagens que você tem instaladas:

JavaScript

docker images

1

docker images
Apagando uma imagem:

JavaScript

docker rm id_do_container

1

docker rm id_do_container
Fazendo o Build das imagens usando o Docker Compose:

JavaScript

docker-compose build

1

docker-compose build
Criando e subindo os containers via Docker Compose:

JavaScript

docker-compose up

1

docker-compose up
Parando os containers via Docker Compose:

JavaScript

docker-compose stop

1

docker-compose stop
Executando um comando dentro de um container via Docker Compose:

JavaScript

docker-compose run namo_do_service comando

1

docker-compose run namo_do_service comando
Vendo a sua configuração do Docker Compose:

JavaScript

docker-compose config

1

docker-compose config
Vendo os logs dos containers via Docker Compose:

JavaScript

docker-compose logs

1

docker-compose logs
Matando os containers via Docker Compose:

JavaScript

docker-compose kill

1

docker-compose kill
Escalando seus containers (Aumentando a quantidade de containers para o mesmo service) via Docker Compose:

JavaScript

docker-compose scale [SERVICE=NUM...]

1

docker-compose scale [SERVICE=NUM...]
Parando e removendo containers usando Docker Compose:

JavaScript

docker-compose down

1

docker-compose down
Startando os containers:

JavaScript

docker-compose start

1

docker-compose start

Se você quiser conhecer mais comandos do Docker clique aqui, do Docker Compose clique aqui.

12 formas de vencer o bloqueio criativo e escrever textos memoráveis (e 6 dicas extras)

Não perca nenhum conteúdo

Receba nosso resumo semanal com os novos posts, cursos, talks e vagas o/

Reveja o Screencast anterior: Dominando o Atom [12 pacotes Incríveis!] e aproveite para se inscrever em nossa newsletter do lado direito do blog em “se inscreva” e receba o Resumo Semanal One Bit Code 🙂

Conclusão

Neste Screncast nós falamos sobre o Workflow do Docker e também sobre o Docker Compose, se você não viu o vídeo, apenas viu o texto, eu recomendo que você assista ao vídeo, lá tem muito mais informações 🙂

Se você ainda não se inscreveu no canal se inscreve que em breve teremos mais vídeos. E aproveita e dá um like lá nesse vídeo \o/

Se você ficou com alguma dúvida comenta aí em baixo ou me adicione no Facebook clicando aqui.

Muito Obrigado por acompanhar este Blog!
Sua presença aqui é uma honra para mim,

Abraços,
Leonardo Scorza.

Quer se tornar um Programador Full Stack Javascript em 8 semanas? 😀

Nós desenvolvemos um treinamento completo onde você vai aprender desde a base da Web (HTML5, CSS, Bulma, Javascript e Es6+) até React e ExpressJs totalmente do zero!

Nele você também vai desenvolver um projeto do inicio até o Deploy (clone do Evernote) e irá aprender como conseguir as melhores vagas no módulo carreira de Programador.

Se você não quer mais perder oportunidades, clique aqui e saiba mais 💪

Primeira vez no OneBitCode? Curtiu esse conteúdo?
O OneBitCode tem muito mais para você!

O OneBitCode traz conteúdos de qualidade, e em português, sobre programação com foco em Ruby on Rails e também JavaScript.
Além disso, aqui sempre levamos à você conteúdos valiosos sobre a carreira de programação, dicas sobre currículos, portfólios, perfil profissional, soft skills, enfim, tudo o que você precisa saber para continuar evoluindo como Programador(a)!

Fique por dentro de todos os conteúdos o/

Nossas redes sociais:

📹 • https://youtube.com/Onebitcode [Live todas as terças-feiras às 19h)
💻 • https://linkedin.com/company/onebitcode
🙂 • https://facebook.com/onebitcode
📱 • https://instagram.com/one_bit_code
🐦 • https://twitter.com/onebitcode

Nossos cursos:

🥇 • Programador Full Stack Javascript em 8 Semanas
💎 • Curso Completo de Ruby
⚙ • Minicurso: API Rails 5 Completo
🐞 • Minicurso de Testes para Ruby on Rails com RSpec

Espero que curta nossos conteúdos e sempre que precisar de ajuda, fala com a gente!
Estamos aqui para você 🙂

Bem-vindo à família OneBitCode o/

0 0 votes

Article Rating

janeiro 17, 2020

10 Comentários

Oldest

Newest Most Voted

Inline Feedbacks

View all comments

Richard

4 anos atrás

o meu apareceu esse erro ao iniciar o app
Permission denied @ dir_s_mkdir – /usr/src/app/my_awesome_app2 (Errno::EACCES)

Responder

Luís

4 anos atrás

Reply to Richard

provavelmente você não habilitou a permissão ao Composer, para ter acessoa a pasta, se for isto basta digitar o comando: sudo chmod +x /usr/local/bin/docker-compose

Responder

kkk

4 anos atrás

Reply to Richard

obrigado

Responder

João Pereira

3 anos atrás

Ótimo material Leornado!
fiz todo tutorial no Windows 7 utilizando o Docker Toolbox. A única coisa que precisei modificar o comando:
docker run -it –rm –user “$(id -u):$(id -g)” -v “$PWD”:/usr/src/app -w /usr/src/app rails rails new –skip-bundle my_awesome_app

retirando o parametro: –user “$(id -u):$(id -g)”
docker run -it –rm -v “$PWD”:/usr/src/app -w /usr/src/app rails rails new –skip-bundle my_awesome_app

outro detalhe foi que acessando o localhost:3000 não linkou com o container.. mas pelo IP do docker, funcionou.

Abraço!

Responder

Alexandre Ferreira

3 anos atrás

Léo, esse tuto tá simplesmente demais, passo-a-passo simples de entender as funcionalidades do Docker.

Fiquei com uma pequena a dúvida na última parte com a utilização do docker-compose se não era necessário criar a network na “unha” com você havia feito na etapa 2 usando:
> docker network create my_awesome_network

Mas observei depois aqui que o docker-compose já cria uma network automaticamente entre os containers.

Responder

Marcos Souza

3 anos atrás

O comando de geração do projeto dá erro no docker pra windows… Não consigo utilizar!

Responder

cassio

2 anos atrás

Ao executar o comando:
docker run -it –rm –user “$(id -u):$(id -g)” -v “$PWD”:/usr/src/app -w /usr/src/app rails rails new –skip-bundle my_awesome_app

Recebo o erro:
docker: Error response from daemon: create $PWD: “$PWD” includes invalid characters for a local volume name, only “[a-zA-Z0-9][a-zA-Z0-9_.-]” are allowed. If you intended to pass a host directory, use absolute path.
See ‘docker run –help’.

Responder

cassio

2 anos atrás

Reply to cassio

Aparentemente consegui, estou com o SO windows, então executei o comando…
docker run -it –rm -v c:\Users\Kcio\DockerCompartilhado:/usr/src/app -w /usr/src/app rails rails new –skip-bundle my_awesome_app

Responder

Joao Paulo

2 anos atrás

Olá,
tive um pequeno problema ao tentar roda o Dockerfile utilizando a linha “RUN apt-get update &&amp” porém , ao remover o &&amp de todo o código consegui rodar a imagem sem problema.

Responder

Fernando

1 ano atrás

Nesta postagem esta sendo utilizado a imagem “rails” do dockerhub (https://hub.docker.com/_/rails), porém essa imagem foi descontinuada, sendo assim teria alguma outra imagem para usar no lugar (já que a versão atual do Rails é a 6 e essa imagem está com a versão do 5 do Rails)?

Responder

Dominando o Docker!

Introdução

Porque Docker?

O que vamos Aprender?

Links falados no Screencast:

Ingredientes:

PARTE 1 – Criando um container com o Ubuntu

PARTE 2 – Criando e subindo um Projeto Rails via Docker

PARTE 3 – Criando e subindo um Projeto Rails via Docker + PostgreSQL + Network

PARTE 4 – Usando o Docker Compose para organizar nossos containers

Comandos do Docker (Lista de comandos úteis)

Não perca nenhum conteúdo

Receba nosso resumo semanal com os novos posts, cursos, talks e vagas o/

Conclusão

Quer se tornar um Programador Full Stack Javascript em 8 semanas? 😀

Primeira vez no OneBitCode? Curtiu esse conteúdo? O OneBitCode tem muito mais para você!

Nossas redes sociais:

Nossos cursos:

Primeira vez no OneBitCode? Curtiu esse conteúdo?
O OneBitCode tem muito mais para você!