É um aplicativo CLI que você pode usar para interagir com o Docker. Use qualquer terminal disponível em seu sistema operacional para digitar os comandos indicados.
Baixe e instale o Docker Desktop, disponibilizado em https://www.docker.com/products/docker-desktop.
Existem versões para Windows, Linux e MacOS. Siga as instruções de instalação.
Você pode obter informações sobre a sua instalação os comando abaixo:
| Comando | Descrição |
|---|---|
| docker version | Exibe a versão atual instalada |
| docker info | Exibe informações sobre o seu ambiente Docker |
Você também pode usar docker --help para obter uma lista de comandos disponíveis.
Vamos instruir o Docker a baixar uma imagem pública e executá-la em um container (ou seja, em um ambiente isolado). Usaremos a imagem 'hello-world' disponível publicamente com o propósito de teste.
docker run hello-world
A imagem hello-world será baixada, um processo iniciará onde um container será instanciado com um nome aleatório, a aplicação será executada (exibindo uma mensagem de boas vindas), e o processo será finalizado. A imagem continuará disponível em seu computador para uso posterior.
É uma boa prática nomear seus containers usando o parâmetro --name NOME-DESEJADO. Isso permite localizar mais facilmente a instância. Por exemplo, vamos criar a instância com o nome hw.
docker run --name hw hello-world
Podemos inspecionar os processos (containers) em execução usando docker ps. Para exibir todos os processos, incluindo os já finalizados, use docker ps -a .
Perceba que o processo anterior continua na lista, porém finalizado. Você pode gerenciá-lo usando:
| Comando | Descrição |
|---|---|
docker stop XYZ |
Para o processo XYZ |
docker start XYZ |
Inicia o processo XYZ |
docker rm XYZ |
Exclui o processo XYZ após finalizado |
docker rm -f XYZ |
Finaliza e exclui o processo XYZ |
Pode-se baixar imagens previamente à execução de um container, usando docker pull ABC. Você também pode listar as imagens baixadas usando docker images, e excluí-las usando docker rmi ABC.
💡 Os identificadores (XYZ e ABC no exemplos) são os nomes dados às imagens/containers. Você também pode utilizar o código identificador aleatório exibido nas listagens (ex. 4b475216876d, f6d0b4767a6c, ...).
Algumas imagens úteis:
| Imagem | Descrição |
|---|---|
| hello-world | Exibe uma mensagem de boas vindas |
| ubuntu | Linux Ubuntu |
| alpine | Linux Alpine (extremamente leve) |
| centos | Linux CentOS |
| bash | Terminal Linux com Bash |
| mysql | Banco de dados MySQL |
| postgres | Banco de dados Postgres |
| mongo | Banco de Dados MongoDB |
| mcr.microsoft.com/dotnet/sdk | Ambiente para desenvolvimento .NET |
| mcr.microsoft.com/dotnet/runtime | Ambiente para execução .NET |
| mcr.microsoft.com/dotnet/aspnet | Ambiente para execução ASP.NET |
| openjdk | Ambiente Java |
| python | Ambiente Python |
| node | Ambiente Node.Js |
| nginx | Servidor web Nginx |
| httpd | Servidor web Apache |
| wordpress | Gerenciador de conteúdo Wordpress |
Para executar um container e automaticamente excluí-lo após sua finalização, use o parâmetro --rm:
docker run --name hw --rm hello-world
Podemos fazer um mapeamento de portas internas do container para que possamos acessá-las de fora. Para isso, usamos -p PORTAEXTERNA:PORTAINTERNA.
docker run -p 8080:80 nginx
O exemplo acima expõe a porta 80 de uma imagem Nginx na porta 8080 de sua máquina. Você pode testar no navegador acessando http://localhost:8080.
Use a opção -d para rodar seu processo em segundo plano (dettached).
docker run --name nginx -d -p 8080:80 nginx
Será criado um container de nome nginx que escuta a porta 8080 e redireciona para a aplicação interna que ouve a porta 80, no caso o Nginx. Ele executará em segundo plano, retornando o controle para o terminal. Você pode visualizá-lo com docker ps.
Você pode querer executar comandos na instância interna. Para isso, use docker exec passando o nome do container e o comando a executar.
Ex. Listando os arquivos da raiz do container:
docker exec nginx ls
Ex. Abrindo um terminal no container (-it mantém o terminal aberto para você utilizá-lo):
docker exec -it nginx bash
As imagens costumam ser o mais leve possível. Porém, você pode instalar outras aplicações nela livremente.
Ex. Instala o editor de textos nano dentro de um container em execução:
apt-get update
apt-get install -y nano
💡 Dica: use o nano para editar /usr/share/nginx/html/index.html e acesse http://localhost:8080 novamente.
Fazemos isso escrevendo a "receita de bolo" de criação da imagem, na forma de um passo-a-passo que será repetido pelo mecanismo de build.
As instruções serão criadas em um arquivo texto nomeado Dockerfile. Nele, escreva os comandos necessários, na ordem de execução.
Primeiro, você deve escolher uma imagem-base para a sua, que será o ponto de partida. Geralmente usa-se uma imagem de uma distribuiução como ubuntu ou alpine, ou então um ambiente pronto para execução de uma linguagem, como node, python ou mcr.microsoft.com/dotnet/aspnet. Também é comum basear-se em imagens de aplicações que atuam como servidores, como nginx, mysql ou mongo. Fazemos isso com o comando FROM.
Ex. Imagem baseada na distro alpine:
FROM alpine
Nessa imagem, teremos acesso ao sistema de arquivos interno. Para definir o diretório de trabalho (assim como fazemos usando cd no ambiente real, usamos WORKDIR. A diferença é que o path sempre estará disponível, sendo criado no processo de build caso não exista ainda.
FROM nginx
WORKDIR /usr/share/nginx/html
💡 Podem ser usados paths relativos, e o comando pode ser utilizado quantas vezes for necessário.
Todos os comandos que precisem ser executados durante o processo de build para a criação do ambiente devem rodar precedidos de RUN, como se fossem digitados em um terminal.
Por exemplo, a sequência abaixo baixa e instala o aplicativo cowsay na imagem.
FROM ubuntu
RUN apt-get update
RUN apt-get install -y cowsay
Os containers precisam ser construídos usando o comando build, e podem ser enviados ao Docker Hub com o comando push (é necessário logar antes, com `docker login´).
Ex.:
docker build -t usuario/tag .
docker push usuario/tag
Outros comandos importantes:
COPY origem destino: copia arquivos externos para dentro de seu container.EXPOSE porta/protocolo: expõe uma portatcpouudpdo container para ser acessada externamente.CMD comando: o camndo indicado será executado, e os parâmetros enviados poderão substituí-lo (ex. o padrão é executar um script de boas vindas, mas ele pode ser substituído pela abertura de um terminal).ENTRYPOINT ["comando"]: o comando será executado, e os parâmetros enviados serão repassados a ele (ex. a aplicação sempre executa, mas pode receber parâmetros de fora).