Como Fazer o Pull de uma Imagem Docker - Guia Passo a Passo

Introdução

O Docker revolucionou a forma como desenvolvemos, implementamos e gerenciamos aplicações. No cerne deste ecossistema estão as imagens Docker, que servem como os blocos de construção para criar e executar aplicações em contêineres. Neste tutorial, vamos guiá-lo pelo processo de pull (puxar) imagens Docker de um registro, um passo crucial para aproveitar o poder do Docker em seus projetos.

Ao final deste laboratório, você será capaz de pesquisar imagens Docker, pull (puxá-las) do Docker Hub e entender como usá-las em suas aplicações em contêineres.

Entendendo as Imagens Docker

Antes de começarmos a pull (puxar) imagens Docker, é importante entender o que são as imagens Docker e como elas funcionam.

O que é uma Imagem Docker?

Uma imagem Docker é um pacote leve e autônomo que contém tudo o que é necessário para executar uma aplicação:

Código da aplicação
Ambiente de runtime (tempo de execução)
Bibliotecas e dependências
Variáveis de ambiente
Arquivos de configuração

As imagens são os templates (modelos) usados para criar contêineres Docker, que são as instâncias em execução dessas imagens.

Repositórios de Imagens Docker

As imagens Docker são armazenadas em repositórios dentro de registros. O registro público mais popular é o Docker Hub, que hospeda milhares de imagens prontas para uso. Alguns pontos-chave sobre o Docker Hub:

Contém imagens oficiais mantidas por fornecedores de software
Hospeda imagens contribuídas pela comunidade, criadas por usuários
Permite que organizações tenham repositórios privados para imagens proprietárias

Nomenclatura de Imagens Docker

As imagens Docker seguem uma convenção de nomenclatura específica:

[registry/]username/repository:tag

Onde:

registry é o nome do host (servidor) do registro (opcional, o padrão é Docker Hub)
username é o nome de usuário ou nome da organização no Docker Hub
repository é o nome da imagem
tag é a versão da imagem (opcional, o padrão é "latest" - mais recente)

Por exemplo: ubuntu:22.04 ou nginx:latest

Verificando a Instalação do Docker

Antes de prosseguir, vamos garantir que o Docker esteja corretamente instalado em seu sistema. Abra um terminal e execute:

docker --version

Você deve ver uma saída semelhante a:

Docker version 20.10.21, build baeda1f

Isso confirma que o Docker está instalado e pronto para uso.

No próximo passo, vamos pesquisar e pull (puxar) nossa primeira imagem Docker.

Pesquisando e Pull (Puxando) Sua Primeira Imagem Docker

Agora que entendemos o que são as imagens Docker, vamos aprender como encontrá-las e pull (puxá-las) do Docker Hub.

Pesquisando Imagens Docker

Antes de pull (puxar) uma imagem, você pode querer pesquisar as opções disponíveis. Use o comando docker search para encontrar imagens no Docker Hub:

docker search ubuntu

Isso mostrará uma lista de imagens relacionadas ao Ubuntu disponíveis no Docker Hub. Você deve ver uma saída semelhante a:

NAME                             DESCRIPTION                                     STARS     OFFICIAL   AUTOMATED
ubuntu                           Ubuntu is a Debian-based Linux operating s...   14938     [OK]
ubuntu-upstart                   Upstart is an event-based replacement for ...   111       [OK]
rastasheep/ubuntu-sshd           Dockerized SSH service, built on top of of...   256                  [OK]
...

A coluna OFFICIAL marcada com [OK] indica imagens mantidas pelo Docker ou pelo fornecedor do software.

Pulling (Puxando) uma Imagem Docker

Para baixar uma imagem Docker para sua máquina local, use o comando docker pull seguido pelo nome da imagem:

docker pull ubuntu:22.04

Este comando pull (puxa) a imagem Ubuntu 22.04 do Docker Hub. Você deve ver o progresso do download semelhante a:

22.04: Pulling from library/ubuntu
2ab09b027e7f: Pull complete
Digest: sha256:2b7412e6465c3c7fc5bb21d3e6f1917c167358449fecac8176c6e496e5c1f05f
Status: Downloaded newer image for ubuntu:22.04
docker.io/library/ubuntu:22.04

A saída mostra que o Docker está baixando as camadas individuais da imagem. Cada camada representa um conjunto de alterações no sistema de arquivos.

Pulling (Puxando) Imagens Sem uma Tag (Etiqueta)

Se você não especificar uma tag (etiqueta), o Docker pull (puxará) a imagem com a tag (etiqueta) latest (mais recente):

docker pull nginx

Isso pull (puxará) a versão mais recente da imagem do servidor web Nginx:

Using default tag: latest
latest: Pulling from library/nginx
a603fa5e3b41: Pull complete
(...more layers...)
Digest: sha256:f9c305f882a7062db720e582ce619686cbe29742eea6e1db6dcf84b200eec560
Status: Downloaded newer image for nginx:latest
docker.io/library/nginx:latest

Pulling (Puxando) de Outros Registros

Por padrão, docker pull baixa imagens do Docker Hub. Para pull (puxar) de outros registros, inclua o nome do host (servidor) do registro:

docker pull mcr.microsoft.com/dotnet/sdk:6.0

Este comando pull (puxa) a imagem .NET SDK 6.0 do Microsoft Container Registry.

Agora que você pull (puxou) algumas imagens Docker, vamos para o próximo passo para aprender como gerenciá-las.

Gerenciando Imagens Docker

Depois de pull (puxar) as imagens Docker, você precisa saber como listá-las, inspecioná-las e gerenciá-las de forma eficaz.

Listando Imagens Docker

Para ver todas as imagens Docker que você baixou para sua máquina local, use o comando docker images (ou seu alias docker image ls):

docker images

Você deve ver uma saída semelhante a:

REPOSITORY    TAG       IMAGE ID       CREATED        SIZE
ubuntu        22.04     58db3edaf2be   3 weeks ago    77.8MB
nginx         latest    605c77e624dd   4 weeks ago    142MB

Esta saída mostra:

REPOSITORY: O nome da imagem
TAG: A versão da imagem
IMAGE ID: Um identificador único para a imagem
CREATED: Quando a imagem foi criada
SIZE: O tamanho da imagem em disco

Inspecionando Imagens Docker

Para obter informações detalhadas sobre uma imagem específica, use o comando docker inspect:

docker inspect ubuntu:22.04

Este comando exibe um array (vetor) JSON contendo todos os detalhes sobre a imagem, incluindo:

Informações sobre as camadas (layers)
Variáveis de ambiente
Arquitetura
Sistema operacional
Configuração

A saída é bastante longa e detalhada. Aqui está um trecho do que você pode ver:

[
    {
        "Id": "sha256:58db3edaf2beXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
        "RepoTags": [
            "ubuntu:22.04"
        ],
        "RepoDigests": [
            "ubuntu@sha256:2b7412e6465c3fc7fc5bb21d3e6f1917c167358449fecac8176c6e496e5c1f05f"
        ],
        ...
    }
]

Histórico da Imagem

Para ver o histórico de camadas (layer) de uma imagem (como ela foi construída), use o comando docker history:

docker history ubuntu:22.04

A saída mostra cada camada que compõe a imagem:

IMAGE          CREATED       CREATED BY                                      SIZE
58db3edaf2be   3 weeks ago   /bin/sh -c #(nop)  CMD ["bash"]                0B
<missing>      3 weeks ago   /bin/sh -c #(nop) ADD file:15efc167a417...     77.8MB

Removendo Imagens Docker

Quando você não precisar mais de uma imagem, pode removê-la para liberar espaço em disco usando o comando docker rmi:

docker rmi nginx

Se for bem-sucedido, o Docker mostra os IDs das imagens removidas:

Untagged: nginx:latest
Untagged: nginx@sha256:f9c305f882a7062db720e582ce619686cbe29742eea6e1db6dcf84b200eec560
Deleted: sha256:605c77e624ddb75e6110f997c58876bba43f0blindividualayeridshereXX
(...more layers deleted...)

Se a imagem estiver sendo usada por um contêiner, você precisará remover o contêiner primeiro ou usar a opção -f (forçar):

docker rmi -f nginx

Agora você sabe como gerenciar suas imagens Docker. Vamos para o passo final, onde usaremos uma imagem para executar um contêiner.

Usando Imagens Docker

Pull (Puxar) imagens Docker é apenas o primeiro passo. Agora, vamos aprender como usar essas imagens para executar contêineres.

Executando um Contêiner a partir de uma Imagem

Para criar e iniciar um contêiner a partir de uma imagem, use o comando docker run:

docker run ubuntu:22.04 echo "Hello from Ubuntu container"

Este comando:

Cria um novo contêiner a partir da imagem ubuntu:22.04
Executa o comando echo "Hello from Ubuntu container" dentro do contêiner
Exibe a saída:

Hello from Ubuntu container

Após executar o comando, o contêiner para porque concluiu sua tarefa.

Executando um Contêiner Interativo

Para iniciar um shell (terminal) interativo dentro de um contêiner, use as opções -i (interativo) e -t (terminal):

docker run -it ubuntu:22.04 bash

Isso fornece um shell bash dentro do contêiner Ubuntu, onde você pode executar comandos:

root@a1b2c3d4e5f6:/## ls
bin   dev  home  lib32  libx32  mnt  proc  run   srv  tmp  var
boot  etc  lib   lib64  media   opt  root  sbin  sys  usr

Para sair do contêiner, digite exit ou pressione Ctrl+D:

root@a1b2c3d4e5f6:/## exit
exit

Executando um Contêiner em Modo Destacado

Para executar um contêiner em segundo plano (modo destacado), use a opção -d:

docker run -d --name nginx-server -p 8080:80 nginx

Este comando:

Cria um contêiner chamado nginx-server a partir da imagem nginx
Executa-o em modo destacado (-d)
Mapeia a porta 8080 em seu host (servidor) para a porta 80 no contêiner
Retorna um ID do contêiner:

e1d0ac1dcb21a93d9d878dcf40c054eb9f3c2b1bf5ecce7c29b6fa8ce6b219c1

Acessando o Contêiner em Execução

Agora você pode acessar o servidor web Nginx em http://localhost:8080 no seu navegador, ou usar curl para verificar se está funcionando:

curl localhost:8080

Isso deve exibir a página de boas-vindas HTML do Nginx:

<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
...
</html>

Listando Contêineres em Execução

Para ver todos os contêineres em execução, use:

docker ps

Isso mostra informações sobre seus contêineres em execução:

CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS          PORTS                  NAMES
e1d0ac1dcb21   nginx     "/docker-entrypoint.…"   30 seconds ago   Up 29 seconds   0.0.0.0:8080->80/tcp   nginx-server

Parando e Removendo Contêineres

Para parar um contêiner em execução:

docker stop nginx-server

Para remover um contêiner parado:

docker rm nginx-server

Você agora usou com sucesso imagens Docker para executar contêineres. Este é o fluxo de trabalho fundamental para usar o Docker em seus processos de desenvolvimento e implantação.

Resumo

Parabéns por concluir este laboratório de imagens Docker. Você aprendeu as habilidades essenciais para trabalhar com imagens Docker:

Entender o que são as imagens Docker e como elas são organizadas em registros
Pesquisar e pull (puxar) imagens Docker do Docker Hub
Gerenciar suas imagens Docker locais, incluindo listá-las, inspecioná-las e removê-las
Usar imagens Docker para executar contêineres em diferentes modos

Essas habilidades formam a base do trabalho com Docker e permitirão que você aproveite a containerização em seu fluxo de trabalho de desenvolvimento. Agora você pode pull (puxar) qualquer imagem Docker de registros públicos ou privados e usá-las para executar aplicações containerizadas.

Próximos passos para aprendizado adicional:

Criar suas próprias imagens Docker com Dockerfiles
Trabalhar com Docker Compose para aplicações de múltiplos contêineres
Usar volumes Docker para armazenamento persistente
Configurar networking (rede) de contêineres

Continue explorando o vasto ecossistema de imagens Docker disponíveis no Docker Hub para encontrar ferramentas e aplicações que podem acelerar seu processo de desenvolvimento.