É 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 portatcp
ouudp
do 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).