Olá Mundo - Java

segunda-feira, 2 de novembro de 2020

Resumo dos principais comandos Docker

Resumo dos principais comandos Docker para acesso rápido:

docker ps - exibe todos os containers em execução no momento, equivale ao "docker container ls". Temos algumas opções interessantes nesse comando:

-a -> exibe todos os containers, independentemente de estarem em execução ou não.
-q -> exibe apenas os ids dos contaners.
-s -> exibe o tamanho do volume.

docker exec -it nome_ou_id_do_container comando - executa um comando dentro do container de forma interativa (-it). Ex: docker exec -it nome_ou_id bash -> inicia um bash dentro do container especificado.
docker run -it NOME_DA_IMAGEM - conecta o terminal que estamos utilizando com o do container.
docker stop ID_CONTAINER - interrompe o container com id em questão. Mata os processos internos.
docker stop $(docker ps -q) - interrompe todos os containers.
docker start ID_CONTAINER - inicia o container com id em questão.
docker pause ID_CONTAINER - pausa o container com id em questão. Não mata os processos internos.
docker unpause ID_CONTAINER - volta a execução do container pausado com id em questão, com os mesmos processos internos.
docker start -a -i ID_CONTAINER - inicia o container com id em questão e integra os terminais, além de permitir interação entre ambos. (-a de attach).
docker attach ID_CONTAINER - Dessa forma vc acessa um terminal já em execução. Para "desanexar" o container do terminal e ele continuar em background use CTRL+P, CTRL+Q.

Apagando imagens e contaners

docker rm ID_CONTAINER - remove o container com id em questão. Se estiver rodando pode usar o --force no final do comando.
docker container prune - remove todos os containers que estão parados.
docker rmi NOME_DA_IMAGEM - remove a imagem passada como parâmetro.
docker container prune - remove todos os containers parados.
docker images prune -a - remove todas as imagens não ligadas a containers.

Portas e variáveis de ambiente

docker run -d -P --name NOME dockersamples/static-site - ao executar, dá um nome ao container(--name). A opção -d é de "detached", para que o terminal não fique preso no container. O -P (maiúsculo) atrela as portas internas do container à portas aleatórias na minha máquina local para poder acessar.
docker run -d -p 12345:80 dockersamples/static-site - define uma porta específica da nossa máquina (12345) para ser atribuída à porta 80 do container.
docker port ID_CONTAINER - mostra as portas mapeadas.
docker run -d -P -e AUTHOR="Fulano" dockersamples/static-site - o -e define uma variável de ambiente AUTHOR com o valor Fulano no container criado. (Neste caso, a imagem usada espera o valor da variável de ambiente.)

Anexando DISCO(Volume)

docker run -v "[CAMINHO_VOLUME_LOCAL]:CAMINHO_VOLUME_CONTAINER" -w /var/www NOME_DA_IMAGEM - cria um container com volume (-v) no respectivo caminho do container, caso seja especificado um caminho local monta o volume local no volume do container. O -w especifica o diretório que o Docker vai iniciar o container, muito útil para quando se precisa executar certos comandos ao iniciar um servidor por exemplo.
docker run --mount type=bind,source=[CAMINHO_VOLUME_LOCAL], target=[CAMINHO_VOLUME_CONTAINER] NOME_DA_IMAGEM - cria um container com um volume usando o mount. Essa forma faz um bind do contaner para um local da nossa maquina.
docker volume create NOME_DO_VOLUME - cria um volume gerenciado pelo Docker. É parecido com associar uma pasta diretamente ao contaner, mas assim ele fica salvo em um lugar específico do Docker(dentro de /var/lib/docker/volumes) e pode ser trabalhado com alguns comandos do docker.
docker volume ls - retorna a lista de volumes criados.
docker run --mount source=[NOME_DO_VOLUME], target=[CAMINHO_VOLUME_CONTAINER] NOME_DA_IMAGEM - cria o contaner com o volume gerenciado, note que nesse caso o type não precisou ser especificado, apenas o nome do volume gerenciado e o destino.
docker run --tmpfs=CAMINHO/NOME_DA_PASTA - cria pastas temporárias no volume. Algumas aplicações podem fazer bastante uso de pastas temporárias. Funciona com Linux apenas.

Informações

docker inspect ID_CONTAINER - retorna diversas informações sobre o container.
docker history ID_CONTAINER - retorna as camadas do container.

Build e publicação

docker build -f Dockerfile . - cria uma imagem a partir de um Dockerfile passando o diretório atual (".").
docker build -f CAMINHO_DOCKERFILE/Dockerfile -t NOME_USUARIO/NOME_IMAGEM . - constrói e nomeia uma imagem não-oficial informando o caminho para o Dockerfile. O ponto (".") indica o caminho do Dockerfile (diretório atual no caso).
docker login - inicia o processo de login no Docker Hub.
docker push NOME_USUARIO/NOME_IMAGEM:versao - envia a imagem criada para o Docker Hub.
docker pull NOME_USUARIO/NOME_IMAGEM - baixa a imagem desejada do Docker Hub.
docker tag NOME_USUARIO/NOME_IMAGEM:versao NOVO_NOME_USU/NOVO_NOME_IMG:versao - muda o nome da imagem, isso pode ser necessário para fazer o upload de imagens no repositório.

Rede

docker network ls - mostra as redes disponíveis. Embora já exista uma rede bridge, para termos controle somos obrigados a criar a nossa.
docker network create --driver bridge NOME_DA_REDE - cria uma rede especificando o driver desejado.
docker run -it --name NOME_CONTAINER --network NOME_DA_REDE NOME_IMAGEM - cria um container especificando seu nome e qual rede deverá ser usada. Quando uma rede é usada e o container tem um nome, o Docker se encarrega de fazer o DNS entre os nós da rede, podendo assim chamarmos as máquinas pelos nomes atribuídos.
hostname -i - mostra o ip atribuído ao container pelo docker (funciona apenas dentro do container).

Docker Compose

docker-compose build - Realiza o build dos serviços relacionados ao arquivo docker-compose.yml, assim como verifica a sua sintaxe.
docker-compose up -d - Sobe todos os containers relacionados ao docker-compose, desde que o build já tenha sido executado.
docker-compose down - Para todos os serviços em execução que estejam relacionados ao arquivo docker-compose.yml.
docker-compose ps - lista os serviços que estão rodando.

Atenção! Nas versões mais novas foi retirado o hífen ("-") entre as palavras "docker compose" nos comandos.

Exemplo de arquivo docker-compose: docker-compose.yml

OBS: para acessar as máquinas caso esteja usando o Docker Tool Box ao invés do Docker for Windows é preciso ver o IP da máquina. Isso pode ser feito com o comando: docker-machine ip.

OBS2: $docker ps -q retorna os ids dos containers.

Exemplo de arquivo docker-compose.yml

Este exemplo peguei do curso da Alura que sou assinante:

version: '3'

services: 
  nginx: # criando serviço tendo que buildar um projeto
    build:
      dockerfile: ./docker/nginx.dockerfile  # local do arquivo
      context: .                             # pasta raiz do contexto
    image: douglasq/nginx                    # nome da imagem
    container_name: nginx                    # nome do container -> importante, usado para conexão de rede por exemplo
    ports:
      - "80:80" # o - representa um array
      - "443:443"
    networks: 
      - rede-alura2 # pode estar visivel em mais de uma rede
    depends_on: 
      - "node1" # dependencia e usado o nome dado ao servico, nao o nome da imagem
      - "node2"
      - "node3"

  mongodb: # criando servico usando imagem pronta sem alteracao
    image: mongo
    networks: 
      - rede-alura2

  node1:
    build:
      dockerfile: ./docker/alura-books.dockerfile
      context: .
    image: douglasq/alura-books
    container_name: alura-books1
    ports:
      - "3000"
    networks: 
      - rede-alura2
    depends_on: 
      - "mongodb" # dependencia e usado o nome dado ao serviço, nao o nome da imagem
  
  node2:
    build:
      dockerfile: ./docker/alura-books.dockerfile
      context: .
    image: douglasq/alura-books
    container_name: alura-books2
    ports:
      - "3000"
    networks: 
      - rede-alura2
    depends_on: 
      - "mongodb" # dependencia e usado o nome dado ao servico, nao o nome da imagem

  node3:
    build:
      dockerfile: ./docker/alura-books.dockerfile
      context: .
    image: douglasq/alura-books
    container_name: alura-books3
    ports:
      - "3000"
    networks: 
      - rede-alura2
    depends_on: 
      - "mongodb" # dependencia e usado o nome dado ao serviço, nao o nome da imagem

networks: 
  rede-alura2:
    driver: bridge      

Usando o Maven para logar no Docker Hub e publicar a imagem da sua aplicação

Nesse artigo vou mostrar como configurar uma aplicação Maven para logar no Docker Hub através do arquivo settings.xml da pasta .m2 e então publicar a imagem do seu projeto.

Assumimos que você já tem seu projeto configurado para usar o Docker, ou seja, já tem o Dockerfile configurado. Vamos configurar então o pom.xml pois é nele que vamos dizer o repositório do projeto e que ele deve se logar pelas configurações do Maven:

<build>
	<plugins>
	<plugin>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-maven-plugin</artifactId>
	</plugin>
	<plugin>
	<groupId>com.spotify</groupId>
	<artifactId>dockerfile-maven-plugin</artifactId>
	<version>1.4.6</version>
	<executions>
	<execution>
	<id>default</id>
	<goals>
	<goal>build</goal>
	<goal>push</goal>
	</goals>
	</execution>
	</executions>
	<configuration>
	<useMavenSettingsForAuth>true</useMavenSettingsForAuth>
	<repository>seuDockerID/seuProjeto</repository>
	<tag>${project.version}</tag>
	<buildArgs>
	<JAR_FILE>${project.build.finalName}.jar</JAR_FILE>
	</buildArgs>
	</configuration>
	</plugin>
	</plugins>
</build>

Agora vamos configurar o arquivo settings.xml que fica dentro da pasta .m2 e contém configurações globais do maven para sua máquina. É possível que esse arquivo não exista na sua máquina, pois ele não é obrigatório para o Maven funcionar.

<?xml version="1.0" encoding="UTF-8" standalone="no"?>

<settings

xmlns="http://maven.apache.org/SETTINGS/1.0.0"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0

http://maven.apache.org/xsd/settings-1.0.0.xsd">

<id>docker.io</id>

<username>seu_usuario</username>

<password>sua_senha</password>

<email>seu_email</email>

</configuration>

</server>

</servers>

<repository>seuDockerID/seuProjeto</repository> //o mesmo usado no pom.xml

<tag>${project.version}</tag>

</configuration>

</settings>

Agora basta você gerar o seu projeto com o Maven seja pelo comando mvn package ou mvn clean install que o Maven vai gerar sua imagem Docker! Basta você executar o comando Docker images para ver sua nova imagem criada 😊!

Para enviar para o Docker Hub basta executar o comando mvn dockerfile:push.

Pronto, assim o ciclo de geração e publicação de imagens Docker ficou controlado pelo Maven.

Fonte: https://medium.com/@fernandoevangelista_28291/criando-e-enviando-imagem-docker-com-java-e-maven-4fa3c70dba0f