geovannaotoni/docker.md

## docker.md

      
    Raw
  

              docker.md
            
          
    Principais Comandos do Docker via CLI

Gerenciando Imagens


docker images: visualizar todas as imagens Docker presentes na máquina;
docker pull <nome-da-imagem>:<tag>?: baixar uma imagem do Docker Hub sem necessariamente executar esta imagem como um container;
docker rmi <nome/id-da-imagem>: remover uma imagem Docker (acrônimo das palavras ReMover Imagem);
docker build: construir uma imagem a partir de um Dockerfile;

Gerenciando Container


docker <comando> <subcomando> <parâmetros>: (Os  <parâmetros> são opcionais na execução dos comandos);
docker container ls: listar todos os containers em execução no momento na máquina;
docker container ls -a: exibe também containers que foram parados ou que terminaram sua execução;

Ou docker ps -a


docker container run <flags>? <imagem>:<tag> <argumentos>?: comando padrão para subir um container
docker rm <nome-do-container>: remove pelo nome os containers parados ou com execução terminada;
docker rm <id-do-container>: remove pelo id;
docker rm -f <nome/id-do-container>: apaga um container pelo seu nome ou id, até mesmo se ele estiver ativo (utilizando a flag -f para forçar o comando);
docker container start <nome/id-do-container>: iniciar um container já criado e parado na lista;
docker container stop <nome/id-do-container>: comando que força o container a terminar sua execução atual;
docker logs <flags> <nome-do-container>: comando que permite ver  informações (logs, erros, etc) que o programa em segundo plano está executando ou ainda logs de um container parado (execução finalizada)
docker container prune: remove todos os containers inativos do computador;
docker top <nome-do-container>: verificar a lista de processos de um container específico;
docker exec -it <nome-do-container> <comando-a-ser-executado>: Executa um comando em um contêiner em execução.

<comando-a-ser-executado>: exemplo: programa sh (programa de terminal linux), permite simular um acesso de terminal dentro do container que já está em execução;


docker attach <nome/id-do-container>: acessar dentro do container e se conectar ao seu terminal, caso esse container esteja executando um processo interativo;
docker cp index.js <nome-do-container>:/pasta: copiar o arquivo index.js do computador para a pasta do container;
docker create <imagem>:<tag>?: cria um novo container, sem inicializá-lo.

Exemplo:

docker container run alpine:3.14 echo "Hello World": (docker container run <flags>? <imagem>:<tag> <argumentos>?)

o run cria um novo container;
Os parâmetros <flags>? e <argumentos>? são opcionais;
os parâmetros <imagem>:<tag> são a imagem Docker e a versão, exemplo alpine 3.14;


Principais Flags

--name <nome-da-sua-escolha>: flag para dar um nome específico ao container criado, em vez de obter um nome aleatório do Docker;
--rm: flag para que um container seja removido ao final da sua execução (Modo “auto-remover”);
-d ou --detach: flag para que a execução do container ocorra em segundo plano, ou seja, embora não esteja visível, o container executará de forma assíncrona;
-it:

Flag -t: solicita a criação de uma sessão de terminal;
Flag -i: necessária para que a sessão seja interativa;


-v <caminho-da-pasta-com-arquivo-local>:<caminho-do-container>: criar um volume a ser compartilhado entre o computador local e o container.
-e <nome_variavel>=<valor>: informar as variáveis de ambiente.

Comandos dentro de uma sessão interativa de terminal:

ps aux: lista todos os processos em execução no momento;
exit: sair da do terminal do container.

Definições


Imagem: aplicação empacotada com todas as dependências necessárias já instaladas dentro dela.
Container: processo totalmente isolado que representa a execução de uma imagem já construída anteriormente. Pode-se ter vários containers reproduzindo uma mesma imagem Docker.
Dockerfile: arquivo que contém as instruções necessárias para construir uma imagem Docker.

Criando o arquivo Dockerfile


Principais palavras reservadas, utilizadas dentro do arquivo:


FROM <nome-da-imagem>:<tag>?: nome da imagem base para construção da nova imagem;
FROM <nome-da-imagem>:<tag>? AS <nome-do-estagio> : serve para nomear o estágio atual durante o build (a última referência de FROM é a imagem final);
WORKDIR /pasta: indica qual é pasta atual de trabalho dentro da imagem;
COPY index.html /caminho/da/imagem: copiar um arquivo no computador local e colocá-lo dentro da imagem, no caminho especificado à frente;

Flag --from=nome-do-estagio-anterior /caminho/do/arquivo /caminho/estagio/atual: possui a capacidade de copiar arquivos entre os estágios, indica que deve-se copiar o seguinte arquivo ou pasta de um estágio para o estágio atual;


EXPOSE port: dizer em qual porta a aplicação vai rodar (por padrão é 80), esse comando não abre nenhuma porta, é apenas para fins de documentação;
ENV key value: setar variáveis de ambiente que podem ser utilizadas dentro do container
RUN: indica que o comando à frente deve ser executado imediatamente, durante o processo de build;
ENTRYPOINT: indica qual comando deve ser executado ao iniciar a imagem como um container;
CMD ["echo", "hello world"] ou CMD echo "hello world": sugestão de comando a ser executado ao iniciar essa imagem como um container (aceita uma lista de parâmetros ou apenas os comandos). Pode ser substituído ao executar o comando docker run <nome-da-imagem> <comando> <argumentoX>;


No terminal:


docker build <flags>? -t <nome-da-imagem>:<tag>? <contexto>: Construir a imagem

-t: indica qual será o nome da imagem;
<contexto>: caminho de pasta para o Docker se basear para processar o arquivo Dockerfile. Geralmente utiliza-se apenas  . , que indica a pasta atual.


docker run -d -p 1234:80 --name <nome-do-novo-container> <nome-da-minha-imagem> : Executar um novo container com a imagem criada

-p 1234:80: solicita ao Docker que faça um mapeamento da porta 1234 do nosso computador para a porta 80 da rede do container (faz o bind das portas)
-P: com P maiúsculo, escolhe uma porta da máquina aleatoriamente para, ao acessar o localhost naquela porta específica, redirecionar para a porta 80 do container.


Docker Compose: Gerenciar múltiplos containers


Dentro do arquivo docker-compose.yaml:

version: "3"
services:
  frontend:
    build: frontend/
    restart: always
    ports:
      - 3000:3000
    depends_on:
      - backend
    volumes:
      - ./logs:/var/log/frontend
    networks:
      - rede-virtual-1
  backend:
    build: backend/
    restart: always
    ports:
      - 3001:3001
    environment:
      - DB_HOST=database
    depends_on:
      - database
    networks:
      - rede-virtual-1
      - rede-virtual-2
  database:
    image: betrybe/docker-compose-example-database:v1
    restart: always
    volumes:
      -dados-do-banco:data/db
    networks:
      - rede-virtual-2

volumes:
  dados-do-banco:

networks:
  rede-virtual-1:
  rede-virtual-2:

version: todo arquivo deve iniciar com a chave version, que indica a versão do Arquivo Compose;
services: Definir os serviços e especificar a imagem de cada um:

image: <nome-da-imagem>: imagem Docker pronta, seja local ou a ser baixada;
build: pasta/: pasta contendo um arquivo Dockerfile a partir do qual o Compose vai executar o comando docker build automaticamente;


ports: - portaLocal:portaContainer: mapear as portas entre o computador local e as portas do container;
restart: <comando>: Política de reinicialização: através da chave restart.

no: o container não reiniciará automaticamente (padrão);
on-failure: o container será reiniciado caso ocorra alguma falha apontada pelo exit code (diferente de zero);
always: sempre que o serviço parar, seja por uma falha ou porque ele simplesmente finalizou sua execução, ele deverá ser reiniciado;
unless-stopped: o container sempre será reiniciado, a menos que se utilize o comando docker stop  manualmente.


environment: - NOME_DA_VARIÁVEL=VALOR: criar variáveis de ambiente dentro dos containers;
depends_on: - <nome-do-serviço>: lista de serviços que o Compose deve executar antes de executar o serviço atual;
volumes::

ao final do arquivo: especifica para o Compose que ele deve criar um volume virtual com o nome passado como argumento.
no frontend: mapeia uma pasta do computador local para uma pasta dentro do serviço de front-end: caminho/no/computador:caminho/no/container
no database: <nome-do-volume>:<caminho-no-container-para-montar>


networks:: redes virtuais que permitem criar isolamento entre os serviços.

ao final do arquivo: declara-se o nome de uma nova rede virtual por linha;
dentro de cada serviço: declara-se a rede para permitir a comunicação direta entre os serviços;


container_name: <nome-do-container>: nomear o container a ser criado;
command: <comando>: executar o comando ao iniciar o container (mesma função do CMD no Dockerfile);


No terminal, dentro da pasta que contém o arquivo docker-compose.yaml:


docker-compose up -d: subir todos os serviço.
docker-compose ps: verificar o status dos serviços.
docker-compose up -d --build: reconstruir as Imagens Docker após alguma alteração.
docker-compose down: parar a execução de todos os serviços.
docker-compose up <serviço>: subir serviços específicos.
docker-compose logs <nome-do-serviço>: visualizar os logs de um dos serviços.
docker-compose up --scale service=<número-de-replicas>: configurar a quantidade de réplicas (cópias de containers) para um mesmo serviço.

Demais comandos Docker na documentação oficial: https://docs.docker.com/engine/reference/commandline/docker/.
Todos os direitos reservados à documentação oficial do Docker e à Trybe, cujos materiais serviram de base para a construção deste gist.