# Tutorial Docker: Instalação e operação passo a passo da plataforma de contêineres

*Build, Ship, and Run Any App, Anywhere* ou, em tradução livre, “Crie, envie e execute qualquer aplicativo, de qualquer lugar”, é o lema do Docker. A plataforma de contêineres de código aberto oferece uma alternativa flexível, já que requer poucos recursos para emular componentes de hardware baseados em máquinas virtuais (VMs). No nosso tutorial de Docker para iniciantes, comparamos as diferenças entre as duas técnicas de virtualização, apresentamos o projeto de código aberto Docker e damos instruções claras e detalhadas sobre sua utilização.

Enquanto a virtualização de hardware tradicional é baseada na inicialização de múltiplos sistemas convidados em um sistema de hospedagem comum, as aplicações Docker são executadas como processos isolados em um mesmo sistema, com a ajuda de contêineres. Esse processo recebe o nome de [virtualização baseada em contêineres](https://www.ionos.com/digitalguide/server/know-how/server-containers-virtualisation-without-emulation/ "Virtualização de contêineres de servidores sem emulação"), sendo também conhecido como **virtualização em nível de sistema operacional**.

A imagem a seguir mostra diferenças fundamentais na estrutura arquitetônica de cada uma das técnicas de virtualização:

[![Imagem: Comparação entre máquinas virtuais e contêineres softwares](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/f/9/csm_virtual-machines-compared-to-docker-containers_1216df397f.webp "Comparação entre máquinas virtuais e contêineres softwares")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Schaubilder/virtual-machines-compared-to-docker-containers.png) Enquanto cada máquina virtual inicializa seu próprio sistema operacional, contêineres Docker compartilham o núcleo do sistema de hospedagem As duas técnicas possibilitam que desenvolvedores e administradores de sistemas usem paralelamente diversas aplicações, com requisitos diferentes, no mesmo sistema. As principais diferenças entre elas estão relacionadas ao **consumo de recursos** e à **portabilidade**.

## Contêiner: Virtualização com utilização mínima de recursos

Quando aplicações são encapsuladas em um processo de virtualização de hardware tradicional, o encapsulamento é realizado por um [*hipervisor*](https://www.ionos.com/digitalguide/server/know-how/what-is-a-hypervisor/ "O que é hipervisor"). Ele atua como uma camada de abstração entre o sistema de hospedagem e os sistemas virtuais convidados. Cada sistema convidado é implementado como uma **máquina completa, com um núcleo de sistema operacional exclusivo**. Recursos de hardware do sistema de hospedagem (CPU, memória, espaço em disco rígido e periféricos disponíveis) são atribuídos proporcionalmente pelo *hipervisor*.

Por outro lado, na virtualização baseada em contêineres, **nenhum sistema convidado completo** é simulado. Em vez disso, as aplicações são iniciadas nos contêineres. Elas compartilham o mesmo núcleo (o sistema de hospedagem), mas são executadas como **processos isolados** no espaço de usuário.

Nota Em geral, sistemas operacionais modernos compartilham a memória virtual em duas áreas separadas: no espaço de núcleo (*core space*) e no espaço de usuário (*user space*). Enquanto o **espaço de núcleo** é reservado exclusivamente à operação do núcleo e de outros componentes do sistema operacional, o **espaço de usuário** representa a área da memória disponível para aplicações. A separação entre o espaço de núcleo e o espaço de usuário é feita principalmente para proteger o sistema contra aplicações perigosas ou defeituosas.

Uma grande vantagem da virtualização baseada em contêineres é que aplicações com requisitos diferentes podem ser executadas isoladamente umas das outras, sem que ocorra **sobrecarga em um sistema convidado separado**. Para tanto, a tecnologia de contêineres usa duas funções básicas do núcleo Linux: **grupos de controle (*cgroups*)**e**espaços de nome (*namespaces*) do núcleo**.

- Os ***cgroups*** limitam o acesso dos processos à memória, CPU e recursos I/O, e previnem que os requisitos de um processo afetem os demais em execução.
- Os ***namespaces*** limitam um processo e seus processos filhos a uma porção específica de um sistema subjacente. Para processos encapsulados, o Docker usa espaços de nome em cinco áreas diferentes:
- **Identificação de sistema (UTS)**: Espaços de nomes UTS são usados na virtualização baseada em contêineres para atribuir *host* e nomes de domínio aos contêineres.
- **IDs de processo (PID)**: Todo contêiner Docker usa um espaço de nomes único para processar IDs. Processos executados fora de um contêiner não são visíveis dentro dele. Portanto, processos encapsulados em contêineres no mesmo sistema de hospedagem podem ter o mesmo PID sem que ocorram conflitos.
- **Comunicação entre processos (IPC)**: Espaços de nomes IPC isolam processos em um contêiner, de forma que a comunicação fora desse contêiner é impedida.
- **Recursos de rede (NET)**: Com os espaços de nomes de rede, cada contêiner pode receber recursos de rede separados, como endereços IP ou tabelas de roteamento.
- **Pontos de montagem do sistema de arquivos (MNT)**: Graças aos espaços de nomes de montagem, um processo isolado nunca enxerga o sistema de arquivos inteiro do *host*, apenas uma pequena parte dele (em geral, uma imagem criada especificamente para esse contêiner).

Até a versão 0.8.1, o Docker baseava seus processos somente em [contêineres Linux (LXC)](https://www.ionos.com/digitalguide/server/know-how/what-is-lxc-linux-containers/ "O que é LXC: Contêineres Linux"). Desde a versão 0.9, o formato de contêiner **Libcontainer** passou a ser disponibilizado aos usuários. Ele possibilita que o Docker seja implementado em diversas plataformas e execute o mesmo contêiner em vários sistemas de hospedagem. A mudança também permitiu que uma versão do Docker fosse disponibilizada para os sistemas operacionais Windows e macOS.

## Escalabilidade, alta disponibilidade e portabilidade

A tecnologia de contêineres não representa apenas uma alternativa que requer menos recursos quando comparada à virtualização de hardware tradicional. Contêineres softwares também permitem que **aplicações sejam configuradas entre plataformas e em infraestruturas diferentes**, sem que configurações especiais de hardware ou software sejam necessárias no respectivo sistema de hospedagem.

O Docker usa **imagens portáteis** para contêineres softwares. As imagens de contêiner contêm aplicações individuais, incluindo todas as bibliotecas, arquivos binários e arquivos de configuração necessários para executar os processos de aplicações encapsuladas. Elas exigem poucos recursos do respectivo sistema de hospedagem, o que permite que o contêiner de uma aplicação seja realocado entre diversos sistemas Linux, Windows ou macOS, sem configuração adicional (desde que a plataforma Docker tenha sido instalada como camada de abstração). Devido a essas características, o Docker tornou-se a base ideal para a implementação de arquiteturas de software escaláveis e de alta disponibilidade. Ele é usado em sistemas de produção de empresas como Spotify, Google e eBay.

## Docker: Estrutura e funções

O Docker é o projeto de software mais popular de **tecnologia de virtualização baseada em contêineres**. A plataforma de código aberto tem três componentes básicos: o **Docker Engine**, o **Docker Images** e o **Docker Hub**. Para executar contêineres, usuários precisam do Docker Engine e de Docker Images (imagens Docker). Estas podem ser obtidas por meio do Docker Hub, ou criadas manualmente.

### Docker Images (imagens Docker)

Similares a máquinas virtuais, contêineres Docker são baseados em imagens. Uma imagem é uma *template* somente para leitura, que contém todas as instruções que o Docker Engine precisa para criar um contêiner. Uma imagem Docker pode ser descrita como **uma imagem portátil de um contêiner em formato de arquivo de texto**, também chamado de *Dockerfile*. Se um contêiner for inicializado em um sistema, um pacote com a respectiva imagem é previamente carregado (desde que ele não exista localmente). A imagem carregada fornece o **sistema de arquivos que inclui todos os parâmetros necessários** para a execução. Um contêiner pode ser considerado um processo de execução de uma imagem.

### Docker Hub

O [Docker Hub](https://hub.docker.com/ "Repositório oficial do Docker em hub.docker.com") é um **registro para repositórios de software** baseado em nuvem. Em outras palavras, ele é a biblioteca das imagens Docker. O serviço on-line é dividido em uma seção pública e uma privada. A seção pública permite que usuários enviem suas próprias imagens e compartilhem-nas com a comunidade. Diversas imagens oficiais disponibilizadas pela equipe de desenvolvimento do Docker e de outros projetos de código aberto consagrados também podem ser encontradas no Docker Hub. Imagens enviadas para a seção privada do repositório não podem ser acessadas publicamente e só são compartilhadas, por exemplo, dentro do círculo interno de uma empresa, ou entre amigos e conhecidos.

### Docker Engine

O Docker Engine seria, por assim dizer, o coração do projeto Docker. Ele é uma **aplicação cliente-servidor de código aberto**, disponível a todos os usuários da versão atual, em todas as plataformas. A arquitetura básica do Docker Engine é dividida em três componentes: ***daemon***com funções de servidor;**interface de programação (API)**baseada no paradigma de programação REST (*Representational State Transfer*); e**terminal do sistema operacional** (interface de linha de comando ou CLI), que funciona como interface de usuário (cliente).

- **Docker *daemon***: O processo*daemon* atua como servidor para o Docker Engine. Ele é executado em segundo plano no sistema de hospedagem e usado no controle central do Docker Engine. Esta função cria e gerencia todas as imagens, contêineres e redes.
- **REST-API**: A REST-API especifica um conjunto de interfaces que permite que outros programas se comuniquem com o Docker *daemon* e passem instruções a ele. Um desses programas é o terminal do sistema operacional.
- **Terminal**: O Docker usa o terminal do sistema operacional como um programa de cliente. A integração do terminal com o Docker *daemon*, por meio da REST-API, possibilita que usuários estabeleçam comandos usando scripts ou entradas (*inputs*).

Com o Docker, contêineres softwares de usuários podem ser iniciados, interrompidos e gerenciados diretamente do terminal. O *daemon* é abordado pelo **comando** `docker` ou por instruções como `build`, `pull` e `run`. Cliente e servidor podem estar no mesmo sistema. Usuários também têm a opção de acessar um Docker *daemon* em um outro sistema. Dependendo do tipo de conexão estabelecida, a comunicação entre cliente e servidor pode ocorrer por REST-API, sockets UNIX ou interface de rede.

O gráfico abaixo ilustra a **interação entre componentes individuais de Docker** quando comandos como `docker build`, `docker pull` e `docker run` são usados:

[![Imagem: Representação esquemática da arquitetura Docker](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/8/5/csm_representacao-esquematica-arquitetura-docker_c14942fa47.webp "Representação esquemática da arquitetura Docker")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Schaubilder/representacao-esquematica-arquitetura-docker.png) A arquitetura Docker é baseada na cooperação entre cliente terminal, servidor Docker daemon e registro Docker Hub O comando `docker build` instrui o Docker *daemon* a criar uma imagem (linha pontilhada). Para criá-la, é necessário que o *Dockerfile* correspondente esteja disponível. Se a imagem não for criada, mas carregada de um repositório do Docker Hub, o comando `docker pull` deve ser usado (linha tracejada). Já se o Docker *daemon* receber a instrução por `docker run` para iniciar um contêiner, o programa em segundo plano verifica se a imagem do contêiner correspondente está disponível localmente. Se estiver, o contêiner é executado (linha sólida). Se o *daemon* não encontrar a imagem, ele iniciará automaticamente um comando `pull` no repositório.

## Instalação do Docker Engine

Embora o Docker tenha sido usado inicialmente apenas em distribuições Linux, a versão atual da tecnologia de contêineres se caracteriza por seu **alto grau de independência de plataformas**. Pacotes de instalação estão disponíveis para Microsoft Windows e macOS, bem como para serviços em nuvem, como Amazon Web Services (AWS) e Microsoft Azure. A **distribuições Linux** suportadas incluem:

- CentOS
- Debian
- Fedora
- Oracle Linux
- Red Hat Enterprise Linux
- Ubuntu
- openSUSE
- SUSE Linux Enterprise

Além disso, distribuições Docker administradas pela comunidade também estão disponíveis para:

- Arch Linux
- CRUX Linux
- Gentoo Linux

Como exemplo, neste tutorial Docker ilustraremos o processo de instalação do Docker Engine usando a popular distribuição Linux **Ubuntu**. Orientações detalhadas sobre o [processo de instalação do Docker em outras plataformas](https://docs.docker.com/engine/installation/ "Documentação do Docker – Instalar Docker") podem ser encontradas na documentação oficial do contêiner software.

Dependendo dos requisitos a serem atendidos, existem três formas diferentes de instalar a plataforma de contêineres Docker em um sistema Ubuntu:

- Instalação **manual** com **pacote .DEB**
- Instalação pelo **repositório Docker**
- Instalação pelo **repositório Ubuntu**

Antes de fazer sua escolha e mergulhar no nosso tutorial Docker, você deve conhecer os requisitos de sistema do Docker Engine.

### Requisitos de sistema

Para instalar a versão atual do Docker em uma distribuição Ubuntu, você precisa ter a **variante de 64 bits** de uma das seguintes versões do Ubuntu:

- Yakkety 16.10
- Xenial 16.04 (LTS)
- Trusty 14.04 (LTS)

Nota Em sistemas produtivos, recomendamos o uso de softwares com suporte de longo prazo (LTS). Eles são disponibilizados pelo fornecedor com atualizações, mesmo que uma versão sucessora esteja sendo distribuída no mercado.

### Antes de instalar o Docker

O tutorial Docker a seguir é baseado no **Ubuntu versão Xenial 16.04 (LTS)**. O processo de instalação segue os mesmos passos na versão Yakkety 16.10. Para usuários de Trusty 14.04, recomendamos a instalação de pacotes \*linux-image-extra-\* antes da instalação do Docker. Eles possibilitarão o Docker Engine de acessar o driver de armazenamento AUFS.

Um método prático para atualizar um sistema Linux é oferecido pelo **gerenciador de pacotes APT (*Advanced Packaging Tool*)**. Para instalar o **pacote adicional para Trusty 14.04**, siga estes passos:

1. **Abra o terminal**: Inicie o Ubuntu e em seguida o terminal. Isso pode ser feito pressionando as teclas *CTRL* + *ALT* + *T*.

[![Imagem: Terminal do Ubuntu Xenial 16.04 LTS](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/3/8/csm_DE-terminal-ubuntu_874b6e1e6f.webp "Terminal do Ubuntu Xenial 16.04 LTS")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-terminal-ubuntu.png) Para executar ações no terminal como administrador, use o comando sudo antes de acessar o programa 2. **Atualize a lista de pacotes**: Insira o comando a seguir para atualizar a indexação de pacotes locais do seu sistema operacional. Confirme o comando, pressionando a tecla *ENTER*.

```none
$ sudo apt-get update
```

Nota O comando `apt-get update` não instala novos pacotes. Ele apenas atualiza as descrições dos pacotes instalados localmente.

Ao adicionar `sudo` a comandos, você conseguirá executar esses comandos como administrador (super usuário *root*). Em determinadas circunstâncias, alguns comandos podem exigir permissões *root*. Nestes casos, o Ubuntu solicita que você informe a senha de administrador. Também existe a possibilidade de você mudar permanentemente os comandos para comandos de administrador digitando `sudo -s`.

Nota Para instalar a plataforma de contêineres Docker, você precisa ter permissões *root* para o respectivo sistema de hospedagem.

[![Imagem: Solicitação de senha no terminal do Ubuntu](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/d/4/csm_DE-ubuntu-terminal-passwort_553ceb1dbd.webp "Solicitação de senha no terminal do Ubuntu")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-ubuntu-terminal-passwort.png) Ao inserir uma senha no terminal do Ubuntu, você não verá mais nenhum caractere placeholder Se você se identificou como usuário *root* inserindo uma senha, o Ubuntu iniciará o processo de atualização. O status será exibido no terminal.

[![Imagem: Gerenciamento de pacotes no terminal do Ubuntu por APT](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/3/9/csm_DE-ubuntu-paketverwaltung-apt_c3e3125390.webp "Gerenciamento de pacotes no terminal do Ubuntu por APT")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-ubuntu-paketverwaltung-apt.png) O comando sudo apt-get update no Ubuntu é usado para exibir a lista atualizada dos pacotes disponíveis 3. **Instale pacotes adicionais**: Quando todas as descrições de pacotes forem atualizadas, você poderá prosseguir com a instalação de novos pacotes. O gerenciador de pacotes APT torna isso possível com o comando `apt-get install “NomeDoPacote”`. Para instalar pacotes adicionais recomendados ao Trusty 14.04 pelo repositório Ubuntu, digite o comando a seguir no terminal e pressione a tecla *ENTER*:

```none
$ sudo apt-get install -y --no-install-recommends \
linux-image-extra-$(uname -r) \
linux-image-extra-virtual
```

Nota Se você digitar o comando com a opção `-y`, todas as perguntas interativas serão respondidas automaticamente com “*yes*” (sim). Já a opção `--no-install-recommends` impedirá que o Ubuntu instale automaticamente pacotes recomendados.

[![Imagem: Instalação de pacotes no terminal do Ubuntu](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/3/8/csm_DE-ubuntu-paketinstallation_aa48fd319c.webp "Instalação de pacotes no terminal do Ubuntu")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-ubuntu-paketinstallation.png) Antes de instalar novos pacotes, recomendamos atualizar a lista de pacotes locais Depois de fazer o download dos pacotes adicionais para Trust 14.04, todas as funções da plataforma Docker estarão disponíveis para essa versão do Ubuntu.

Se você não sabe qual versão do Ubuntu está rodando no seu sistema ou não tem certeza se possui a arquitetura de 64 bits necessária para instalar o Docker, você pode solicitar essas informações ao terminal. Basta digitar o seguinte comando para ter acesso à versão e à arquitetura do sistema:

```none
$ sudo uname –rm
```

A respectiva **versão do Ubuntu**, a data de **lançamento** e o ***nickname*** dela são exibidos com o comando a seguir:

```none
$ sudo lsb_release -a
```

[![Imagem: Acesso às informações do sistema Ubuntu no terminal](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/f/c/csm_DE-ubuntu-systeminformationen_bf05fc101e.webp "Acesso às informações do sistema Ubuntu no terminal")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-ubuntu-systeminformationen.png) No Ubuntu, você acessa as informações do sistema com facilidade pelo terminal ### Instalação manual por pacote .DEB

Em princípio, o [pacote de instalação do Docker](https://apt.dockerproject.org/repo/pool/main/d/docker-engine/ "Download do Docker como pacote .DEB") pode ser baixado como um pacote .DEB e **instalado manualmente**. Para tanto, faça o download do arquivo .DEB para sua versão do Ubuntu e inicie o processo de instalação, inserindo o seguinte comando no terminal:

```none
$ sudo dpkg -i /path/to/package.deb
```

Nota Modifique o *placeholder* `/path/to/` para que o caminho do arquivo aponte para o local de armazenamento do pacote .DEB.

No caso de uma instalação manual, **todas as atualizações de software também devem ser feitas manualmente**. A documentação do Docker recomenda que você use o próprio repositório Docker para executá-las, permitindo que a plataforma de contêineres seja instalada de forma prática pelo terminal Ubuntu e permaneça atualizada.

A seguir, nosso tutorial Docker ilustrará um processo de instalação tal qual sugerido pela documentação oficial da plataforma.

### Instalação pelo repositório Docker

Recomendamos a instalação da sua própria plataforma de contêineres pelo repositório Docker. Mostraremos como configurar seu sistema para que o gerente de pacotes APT consiga **acessar o repositório Docker por HTTPS**.

1. **Instale os pacotes**: Insira o comando a seguir para instalar todos os pacotes necessários para acessar o repositório Docker:

```none
$ sudo apt-get install -y --no-install-recommends \
apt-transport-https \
ca-certificates \
curl \
software-properties-common
```

[![Imagem: Instalação do pacote de configuração pelo terminal do Ubuntu](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/4/9/csm_DE-ubuntu-install-konfigurationspakete_eb110df8b5.webp "Instalação do pacote de configuração pelo terminal do Ubuntu")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-ubuntu-install-konfigurationspakete.png) Siga o processo de instalação para ver o resultado no terminal 2. **Adicione a chave GPG**: Adicione a chave GPG oficial do Docker com o comando a seguir.

```none
$ curl -fsSL https://apt.dockerproject.org/gpg | sudo apt-key add -
```

[![Imagem: Adicione a chave GPG com o comando apt-key add](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/4/6/csm_DE-ubuntu-gpg-schluessel_be1ebe8257.webp "Adicione a chave GPG com o comando apt-key add")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-ubuntu-gpg-schluessel.png) Se a chave for adicionada com sucesso, o Ubuntu retornará com a mensagem OK no terminal 3. **Verifique a chave GPG**: Certifique-se de que a chave GPG seja igual a: *ID 5811 8E89 F3A9 1289 7C07 0ADB F762 2157 2C52 609D*. Par tanto, use o comando a seguir:

```none
$ apt-key fingerprint 58118E89F3A912897C070ADBF76221572C52609D
```

O resultado abaixo será exibido pelo terminal:

```none
pub   4096R/2C52609D 2015-07-14
    Key fingerprint = 5811 8E89 F3A9 1289 7C07  0ADB F762 2157 2C52 609D
uid          Docker Release Tool (releasedocker) docker@docker.com
```

[![Imagem: Verificação da chave GPG](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/7/1/csm_DE-ubuntu-gpg-verifikation_3356b8d935.webp "Verificação da chave GPG")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-ubuntu-gpg-verifikation.png) Compare o resultado no terminal com a chave GPG do Docker 4. **Configure o repositório Docker**: Insira o comando abaixo para assegurar o acesso ao repositório estável Docker:

```none
$ sudo add-apt-repository \
    "deb https://apt.dockerproject.org/repo/ \
    ubuntu-$(lsb_release -cs) \
    main"
```

[![Imagem: Configuração do repositório estável Docker](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/e/f/csm_DE-konfiguration-docker-repository_d4f16ac0be.webp "Configuração do repositório estável Docker")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-konfiguration-docker-repository.png) Configure o acesso ao repositório estável Docker Após esses passos, seu sistema estará totalmente configurado para instalar a plataforma de contêineres pelo repositório estável Docker.

Nota Como alternativa ao repositório estável, você também pode acessar o repositório de teste Docker. Para isso, chame o arquivo */etc/apt/sources.list* e substitua a palavra *main* por *testing*. Em sistemas produtivos, não é recomendável usar o repositório de teste.

5. **Atualize a indexação dos pacotes**: Antes de prosseguir com a instalação do Docker Engine, aconselhamos que você atualize a indexação do seu sistema operacional mais uma vez, usando aquele mesmo comando:

```none
$ sudo apt-get update
```

6. **Instale o Docker pelo repositório**: Existem duas opções disponíveis para baixar o Docker Engine do repositório Docker e instalá-lo no seu computador. Para baixar a versão atual do Docker Engine, use o seguinte comando:

```none
$ sudo apt-get -y install docker-engine
```

[![Imagem: Processo de instalação do Docker: exibição de status no terminal](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/d/7/csm_DE-docker-installationsprozess_42ca2ed987.webp "Processo de instalação do Docker: exibição de status no terminal")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-docker-installationsprozess.png) Acompanhe o progresso do processo de instalação no terminal A plataforma de contêineres estará pronta para uso assim que o processo de instalação for concluído. O Docker *daemon* será iniciado automaticamente. Se seu sistema operacional já tiver uma versão antiga do Docker instalada, ela será substituída pelo software atualizado.

Além da versão atual, qualquer **versão mais antiga do Docker Engine** também pode ser instalada. Esse é um recurso útil, por exemplo, para sistemas produtivos. Alguns usuários preferem usar versões consagradas, que garantem uma boa experiência, em vez de versões mais novas, não tão estabelecidas.

Para ter acesso a todas as **versões de Docker disponíveis**, use o seguinte comando:

```none
$ apt-cache madison docker-engine
```

[![Imagem: Versões do Docker Engine apresentadas pelo terminal](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/9/a/csm_DE-docker-versionsuebersicht_e991ba7880.webp "Versões do Docker Engine apresentadas pelo terminal")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-docker-versionsuebersicht.png) Escolha o lançamento desejado do Docker na lista de versões disponíveis do software Para instalar uma versão especial do Docker, basta adicionar o **número da versão** (por exemplo, *1.12.5-0*) ao respectivo comando de instalação, separando-o do nome do pacote (neste caso, *docker-engine*) por um sinal de igual.

```none
$ sudo apt-get -y install docker-engine=<VERSÃO>
```

### Instalação pelo repositório Ubuntu

Usuários que não querem depender do repositório Docker têm a opção de baixar a plataforma de contêineres **pelo repositório do próprio sistema operacional Ubuntu**.

Use o comando abaixo para instalar um pacote Docker criado pela [comunidade Ubuntu](http://packages.ubuntu.com/xenial/docker.io "Saiba mais sobre docker.io em packages.ubuntu.com"):

```none
$ sudo apt-get install -y docker.io
```

Nota O pacote de instalação da plataforma de contêineres *docker.io* não deve ser confundido com o pacote *docker*, uma bandeja do sistema para aplicações KDE3/GNOME2 Docklet.

### Execução de teste

Após concluir o processo de instalação com sucesso, certifique-se de que a plataforma de contêineres esteja funcionando de forma adequada. A equipe de desenvolvimento disponibiliza o contêiner *hello-world* para essa finalidade. **Verifique a instalação do Docker** inserindo o comando a seguir no terminal do Ubuntu e pressionando a tecla *ENTER*:

```none
$ sudo docker run hello-world
```

Nota O Docker *daemon* é vinculado a um socket Unix (ponto de comunicação final fornecido pelo sistema operacional), que é atribuído por padrão ao usuário *root*. Os demais usuários só conseguirão usar comandos Docker com a adição de `sudo`. Isso pode ser alterado com a criação de um grupo Unix com o nome “Docker” e a adição dos usuários desejados. Mais informações sobre o processo podem ser encontradas na [documentação do projeto Docker](https://docs.docker.com/engine/installation/linux/linux-postinstall/ "Criação de grupos no Docker — docs.docker.com").

O comando `docker run` instrui o Docker *daemon* a procurar e iniciar um contêiner com o nome *hello-world*. Se a **instalação do Docker foi realizada sem erros**, o resultado será igual ao exibido na captura de tela abaixo:

[![Imagem: Resultado do contêiner hello-world exibido no terminal](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/f/e/csm_DE-docker-hello-world_7a70a9f777.webp "Resultado do contêiner hello-world exibido no terminal")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-docker-hello-world.png) A saudação Hello from Docker comprova que a instalação do Docker está funcionando corretamente Esse **resultado no terminal** significa o seguinte: para executar o comando `docker run hello-world`, o Docker *daemon* procura a imagem do contêiner correspondente nos arquivos locais do seu sistema. Como você estará executando o contêiner *hello-world* pela primeira vez, a busca do *daemon* não será bem-sucedida. Como resultado, você receberá a mensagem “Unable to find image”.

```none
$ sudo docker run hello-world
[sudo] password for osboxes:
Unable to find image 'hello-world:latest' locally
```

Quando o Docker não conseguir encontrar a imagem desejada no sistema local, o *daemon* iniciará um **processo de download**(*pulling*) no repositório Docker.

```none
latest: Pulling from library/hello-world
78445dd45222: Pull complete
Digest: sha256:c5515758d4c5e1e838e9cd307f6c6a0d620b5e07e6f927b07d05f6d12a1ac8d7
Status: Downloaded newer image for hello-world:latest
```

Após o download bem-sucedido, você receberá a seguinte mensagem: “Downloaded newer image for hello-world:latest”. Então, o **contêiner será inicializado**. Ele incluirá o script simples *hello-world* com a seguinte mensagem dos desenvolvedores:

```none
Hello from Docker!
This message shows that your installation appears to be working correctly.
To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the ‘hello-world’ image from the Docker Hub.
 3. The Docker daemon created a new contêiner from that image which runs the executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it to your terminal.
To try something more ambitious, you can run an Ubuntu contêiner with:
 $ docker run -it ubuntu bash
Share images, automate workflows, and more with a free Docker ID:
 https://cloud.docker.com/
For more examples and ideas, visit:
 https://docs.docker.com/engine/userguide/
```

Basicamente, o texto informa que sua **instalação do Docker está funcionando corretamente**.

### Desinstalação do Docker

**Desinstalar** o Docker Engine pelo terminal é tão fácil quanto instalá-lo. Se você deseja remover o pacote Docker do seu sistema, insira o comando a seguir no terminal do Ubuntu e pressione a tecla *ENTER*:

```none
$ sudo apt-get purge docker-engine
```

Após apresentar as informações necessárias para a desinstalação, o sistema solicitará que o comando seja confirmado.

[![Imagem: Desinstalação do Docker pelo terminal](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/5/f/csm_DE-docker-deinstallation_999d3f38de.webp "Desinstalação do Docker pelo terminal")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-docker-deinstallation.png) Desinstale a plataforma Docker com o comando apt-get purge Para prosseguir, insira “Y” e confirme, pressionando a tecla *ENTER*. Insira “N” se quiser cancelar a desinstalação.

As imagens e os contêineres **não serão removidos automaticamente** quando o Docker Engine for desinstalado. Você pode excluí-los com a ajuda deste comando:

```none
$ sudo rm -rf /var/lib/docker
```

Se **arquivos de configuração** adicionais tiverem sido instalados, também será preciso removê-los manualmente.

## Utilização do Docker

Depois de confirmar que o Docker Engine foi instalado e está rodando perfeitamente, é hora de se familiarizar com as **possibilidades de aplicação** da plataforma de contêineres. Aprenda a controlar o Docker Engine pelo terminal, as possibilidades o que Docker Hub oferece e porque os contêineres Docker podem revolucionar a gestão de aplicações com o nosso tutorial Docker.

### Como controlar o Docker Engine

A partir da versão 16.04, o Ubuntu passou a usar o **programa de segundo plano *systemd***(junção das palavras*system*e*daemon*) para gerenciar processos.*Systemd*é um processo*init*, também usado em outras distribuições Linux, como RHEL, CentOS e Fedora. Normalmente, o*systemd*recebe o ID de processo 1. Por ser o primeiro processo do sistema, o*daemon*é responsável por iniciar, monitorar e encerrar todos os processos seguintes. Nas versões anteriores do Ubuntu (14.10 e mais antigas), o programa de segundo plano*upstart* era o responsável por essa função.

O Docker *daemon* também pode ser controlado pelo *systemd*. Na versão padrão, a plataforma de contêineres é configurada para que o *daemon* seja executado automaticamente quando o sistema é inicializado. Essa configuração padrão pode ser personalizada pela ferramenta de linha de comando ***systemctl***.

Com o *systemctl*, você envia comandos para o *systemd* para controlar um processo ou solicitar seu status. A sintaxe desse comando é a seguinte:

```none
Systemctl [OPÇÃO] [COMANDO]
```

Alguns comandos se referem a recursos específicos (por exemplo, Docker). Na terminologia do *systemd*, eles são chamados de ***units*** (unidades). Neste caso, o comando resulta da respectiva instrução e do nome da unidade a ser abordada.

Se você quiser ativar (*enable*) a **inicialização automática do Docker *daemon***ou desativá-la (*disable*), use a ferramenta de linha de comando*systemctl*, juntamente com os seguintes comandos:

```none
$ sudo systemctl enable docker
$ sudo systemctl disable docker
```

A ferramenta de linha de comando *systemctl* também permite que você consulte o **status de uma unidade**:

```none
$ sudo systemctl status docker
```

Se o Docker Engine estiver ativo no seu sistema Ubuntu, o resultado apresentado no terminal será semelhante ao exibido na captura de tela:

[![Imagem: A consulta via systemctl mostra que o status do Docker Engine é active running, ou seja, está ativo](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/6/1/csm_DE-docker-statusabfrage_829537ae09.webp "A consulta via systemctl mostra que o status do Docker Engine é active running, ou seja, está ativo")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-docker-statusabfrage.png) Consulta via systemctl: o status do Docker Engine é active running, ou seja, ativo Se o seu Docker Engine estiver desativado, você receberá a declaração de status *inactive (dead)*. Neste caso, será necessário iniciar manualmente o Docker *daemon* para executar os contêineres.

[![Imagem: A consulta via systemctl mostra que o status do Docker Engine é inactive dead, ou seja, inativo](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/e/9/csm_DE-docker-statusabfrage-inaktiv_b76d502d94.webp "A consulta via systemctl mostra que o status do Docker Engine é inactive dead, ou seja, inativo")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-docker-statusabfrage-inaktiv.png) Consulta via systemctl: o status do Docker Engine é inactive dead ou inativo Se você quiser **iniciar, interromper ou reiniciar manualmente seu Docker Engine**, use *systemd* com um dos comandos a seguir.

Para **iniciar o *daemon* desativado**, digite *systemctl* em combinação com `start`:

```none
$ sudo systemctl start docker
```

Se precisar **encerrar o Docker *daemon***, use o comando `stop`:

```none
$ sudo systemctl stop docker
```

A **reinicialização do Docker Engine** pode ser realizada com o comando `restart`:

```none
$ sudo systemctl restart docker
```

### Como usar o Docker Hub

Se o Docker Engine é o coração da plataforma de contêineres, o Docker Hub é a alma desse projeto de código aberto, já que é nele que a comunidade se reúne. Neste **repositório baseado em nuvem**, usuários encontram tudo o que precisam para dar vida à instalação do Docker.

O serviço on-line oferece **repositórios oficiais diversificados, com mais de 100.000 aplicações grátis**. Lá, usuários também podem criar arquivos de imagens e compartilhá-los publicamente ou com grupos de trabalho. Além de suporte profissional disponibilizado pela equipe de desenvolvimento, iniciantes também encontram na comunidade um ótimo lugar para *networking*. Ainda, há um **fórum de suporte disponível no [GitHub](https://github.com/docker/hub-feedback/issues "Fórum Docker Hub em github.com")**.

[![Imagem: Registro no Docker Hub](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/b/5/csm_DE-docker-hub-anmeldung_93ec06a570.webp "Registro no Docker Hub")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-docker-hub-anmeldung.png) Crie seu Docker ID pessoal de graça registrando-se no Docker Hub; fonte: hub.docker.com #### Registre-se no Docker Hub

**O registro no Docker Hub é gratuito**. Usuários só precisam ter um endereço de e-mail e escolher um Docker ID. Posteriormente, o ID servirá como seu **espaço de nomes de repositório** e lhe concederá acesso a todos os serviços Docker. Atualmente, esses serviços incluem Docker Cloud, Docker Store e programas em fase beta, além do Docker Hub. O **Docker ID** também é usado para acessar a central de suporte do Docker, bem como o portal de sucesso e o [fórum Docker](https://www.docker.com/docker-community "Fórum oficial Docker").

O processo de registro requer cinco passos:

1. **Escolha um Docker ID**: No primeiro passo, você deve escolher um nome de usuário que, posteriormente, será considerado seu Docker ID pessoal. Um nome de usuário no Docker Hub (e em todos os demais serviços Docker) deve ter entre quatro e 30 caracteres, e conter somente letras minúsculas e números.
2. **Informe um endereço de e-mail**: Seu endereço de e-mail será necessário para confirmar seu registro no Docker Hub.
3. **Defina uma senha**: Escolha uma senha entre seis e 128 caracteres.
4. **Submeta o registro**: Clique no botão “Sign up” para enviar seu registro. Após seus dados serem recebidos, o Docker enviará um link de verificação para o endereço de e-mail que você informou no passo 2.
5. **Confirme o endereço de e-mail**: Na caixa de entrada da sua conta de e-mail, clique no link de verificação recebido para confirmar seu endereço de e-mail e concluir o registro.

Os serviços on-line do projeto Docker serão disponibilizados a você imediatamente após a conclusão do registro. Com eles, você poderá criar repositórios e grupos de trabalho, ou pesquisar recursos públicos no Docker Hub usando a função “Explore”.

[![Imagem: Painel do Docker Hub](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/c/3/csm_DE-docker-hub-dashboard_5a1e0f636b.webp "Painel do Docker Hub")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-docker-hub-dashboard.png) Selecione e configure repositórios e grupos de trabalho no painel do Docker Hub; fonte: hub.docker.com Você também consegue se registrar diretamente pelo terminal do seu sistema operacional, usando o comando `docker login`. O procedimento detalhado está descrito na [documentação do Docker](https://docs.docker.com/engine/reference/commandline/login/ "Comando docker login – Documentação do Docker").

Em princípio, o Docker Hub também é disponibilizado a usuários que **não possuem uma conta ou um Docker ID**. No entanto, nestes casos, somente imagens de repositórios públicos podem ser baixadas. Não é possível enviar (*push*) imagens próprias sem um Docker ID.

#### Crie repositórios no Docker Hub

A **conta gratuita do Docker Hub** disponibiliza somente um repositório privado, mas permite criar repositórios públicos ilimitados. Caso precise de mais repositórios privados, você pode desbloqueá-los com um **upgrade pago**.

Para criar um repositório, siga estes passos:

1. **Escolha um espaço de nomes**: Repositórios recém-criados são atribuídos automaticamente ao espaço de nomes do seu Docker ID. Também é possível utilizar o ID da organização para a qual você trabalha.
2. **Classifique o repositório**: Atribua um nome ao repositório recém-criado.
3. **Adicione uma descrição**: Escreva uma breve descrição, assim como instruções de uso detalhadas.
4. **Configure a visibilidade**: Defina se o repositório será visível a todos (opção “public”) ou apenas para você ou sua organização (opção “private”).

Confirme suas escolhas e clique em “*Create*”.

[![Imagem: Docker Hub: Formulário de criação de repositório](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/4/6/csm_DE-docker-hub-erstellung-repo_c7f14e7ac6.webp "Docker Hub: Formulário de criação de repositório")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-docker-hub-erstellung-repo.png) Seus repositórios serão criados automaticamente no espaço de nomes do seu Docker ID; fonte: hub.docker.com #### Crie equipes e organizações no Docker Hub

Pelo Hub, o Docker disponibiliza uma plataforma baseada em nuvem. Lá, **imagens criadas são gerenciadas centralmente e compartilhadas com grupos de trabalho** de um jeito prático. Na terminologia Docker, esses grupos são chamados de organizações (*organizations*). Assim como contas de usuários individuais, organizações recebem IDs que podem ser usados para distribuir imagens e fazer downloads. Direitos e funções dentro de uma organização podem ser atribuídos a equipes. Por exemplo, usuários da equipe “Owners” têm autoridade para criar repositórios públicos e privados, e atribuir direitos de acesso.

Grupos de trabalho também podem ser criados e gerenciados diretamente no painel. Para mais informações sobre organizações e equipes, consulte a [documentação do Docker](https://docs.docker.com/docker-hub/orgs/ "Grupos de trabalho: Documentação do Docker").

### Trabalhe com imagens e contêineres

Além de um primeiro ponto de contato com os recursos oficiais do Docker, o Docker Hub é também o ponto de partida para a **introdução do uso de imagens e de contêineres**. A própria equipe de desenvolvedores da plataforma disponibiliza uma imagem de demonstração, chamada *whalesay*. Ela será usada como base pelo nosso tutorial de Docker.

#### Baixe imagens Docker

Para encontrar a imagem *whalesay*, acesse a página inicial do Docker Hub e digite o termo *whalesay* na barra de pesquisa, no lado esquerdo da tela, perto do logotipo Docker.

[![Imagem: Função de pesquisa no Docker Hub](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/f/0/csm_DE-docker-hub-suchfunktion_976030e355.webp "Função de pesquisa no Docker Hub")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-docker-hub-suchfunktion.png) Faça uma busca no Docker Hub usando a barra de pesquisa ou o botão Explore; fonte: hub.docker.com Nos resultados da pesquisa, clique no recurso intitulado *docker/whalesay* para acessar o repositório público dessa imagem.

Os repositórios Docker seguem o mesmo padrão: no cabeçalho da página, usuários encontram o título da imagem, a categoria do repositório e a data do último envio (*last pushed*).

[![Imagem: Repositório Docker](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/e/5/csm_DE-docker-repo-webansicht_fc79e7157b.webp "Repositório Docker")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-docker-repo-webansicht.png) No repositório, usuários costumam encontrar todas as informações necessárias para usar uma imagem; fonte: hub.docker.com Cada repositório Docker também disponibiliza os seguintes campos de informação:

- **Descrição curta (*short description*)**: Breve descrição do recurso.
- **Descrição completa (*full description*)**: Descrição detalhada, que costuma incluir instruções de uso.
- **Comando *docker pull*(*docker pull command*)**: Diretiva de linha de comando usada para fazer o download da imagem do repositório (*pull*).
- **Proprietário (*owner*)**: Informações sobre o criador do repositório.
- **Comentários (*comments*)**: Seção de comentários ao final da página.

Os campos de informação disponibilizados pelo repositório mostram que *whalesay* é uma modificação do script de código aberto ***cowsay*** para Perl. O programa, desenvolvido por Tony Monroe em 1999, gera um gráfico ASCII na forma de uma vaca, que é exibida em conjunto com uma mensagem, no terminal do usuário.

Para fazer o download de *docker/whalesay*, use o comando `docker pull` com o seguinte padrão:

```none
$ docker pull [OPÇÕES] NOME [:TAG|@DIGEST]
```

O comando `docker pull` instrui o *daemon* a carregar uma imagem do repositório. Você especifica que imagem é essa ao inserir o título (NOME) dela. Você também pode instruir o Docker sobre qual comando deve ser realizado (*OPÇÕES*). Informações opcionais incluem***tags***(*:TAG*) e**números de identificação**individuais (*@DIGEST*), que permitem fazer o download de uma versão específica de uma imagem.

Uma cópia local da imagem *docker/whalesay* pode ser obtida com o seguinte comando:

```none
$ docker pull docker/whalesay
```

Na maioria das vezes, você pode pular esse passo. Caso você deseje inicializar um contêiner, o Docker *daemon* fará o download automático das imagens do repositório, caso elas não sejam encontradas no sistema local.

#### Inicie imagens Docker como contêineres

Para iniciar uma imagem Docker, use o comando `docker run` com o padrão a seguir:

```none
$ docker run [OPÇÕES] IMAGEM [:TAG|@DIGEST] [CMD] [ARG...]
```

A única parte obrigatória do comando `docker run` é o nome da imagem Docker. Contudo, ao iniciar um contêiner, você também pode definir opções adicionais, *TAGs*e*DIGESTs*. Além disso, o comando `docker run` também pode ser combinado com outros comandos que são executados assim que o contêiner é iniciado. No nosso exemplo, o **CMD** (comando definido pelo criador da imagem e executado automaticamente quando o contêiner é iniciado) foi substituído. Outras configurações opcionais podem ser definidas por meio de **argumentos adicionais**(*ARG…*). Eles possibilitam, por exemplo, adicionar usuários ou transferir variáveis de ambiente.

Digite a seguinte diretiva de linha de comando:

```none
$ docker run docker/whalesay cowsay boo
```

Ela fará o download do script Perl já existente como imagem e o executará em um contêiner. Note que este *whalesay* é bastante diferente do script original.

[![Imagem: Resultado do contêiner docker whalesay no terminal: a baleia diz boo](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/1/2/csm_DE-docker-whalesay-boo_becdf8c2ce.webp "Resultado do contêiner docker whalesay no terminal: a baleia diz boo")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-docker-whalesay-boo.png) Se docker whalesay for executado com o comando padrão, a baleia Docker se limitará a dizer boo Se a imagem *docker/whalesay* for executada, o script resultará em um gráfico ASCII na forma de baleia, com a mensagem “boo”, transmitida com o comando `cowsay` no terminal.

Assim como na execução teste, nas demais o *daemon* também procura primeiro a imagem desejada no diretório de arquivos local. Somente se não houver nenhum pacote com o mesmo título, a busca no repositório Docker é iniciada. Em seguida, o *daemon* inicia o programa *cowsay* modificado. Ao final da execução, o **contêiner será encerrado automaticamente**.

Assim como *cowsay*, *whalesay* do Docker permite modificar a sequência do programa e alterar o texto exibido no terminal. Você pode testar essa função substituindo, no comando, “boo” por qualquer outra frase. Por exemplo, por um meme sobre baleias:

```none
$ sudo docker run docker/whalesay cowsay A baleia é amiga da sereia
```

[![Imagem: Resultado do contêiner docker whalesay no terminal: baleia com mensagem personalizada](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/8/3/csm_DE-docker-whalesay-individuelle-nachricht_861221c1f2.webp "Resultado do contêiner docker whalesay no terminal: baleia com mensagem personalizada")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-docker-whalesay-individuelle-nachricht.png) Faça sua baleia Docker dizer o que você quiser, substituindo as palavras no balão de fala #### Exiba todas as imagens Docker no sistema local

Se você não tem certeza se já fez o download de uma imagem em especial, é possível solicitar uma **lista de todas as imagens presentes no seu sistema local**. Para tanto, use a seguinte diretiva de linha de comando:

```none
$ sudo docker image
```

O comando `docker image` resultará na exibição de todas as imagens locais, com informações como tamanho do arquivo, *tag* e ID da imagem.

[![Imagem: Lista de todas as imagens presentes no sistema local](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/6/5/csm_DE-uebersicht-aller-images_fe114d5ba5.webp "Lista de todas as imagens presentes no sistema local")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-uebersicht-aller-images.png) O terminal exibe as imagens hello-world e docker whalesay Se você iniciar um contêiner, uma cópia da imagem subjacente será baixada do repositório e armazenada permanentemente no seu computador. Isso lhe ajudará a economizar tempo, sempre que quiser acessar a imagem. Um novo download só será realizado se a origem da imagem for alterada. Por exemplo, sempre que a versão for atualizada no repositório.

#### Exiba todos os contêineres no sistema local

Se você quiser obter a **lista de todos os contêineres** em execução no seu sistema, ou já executados no passado, use a diretiva de linha de comando `docker ps`, combinada à opção `--all` ou `-a` (forma abreviada):

```none
$ sudo docker ps -a
```

[![Imagem: Lista de contêineres no sistema local](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/1/0/csm_DE-uebersicht-aller-container_dcc16e7b67.webp "Lista de contêineres no sistema local")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-uebersicht-aller-container.png) O terminal exibe todos os contêineres que foram iniciados no Docker Engine O resultado exibido no terminal contém informações como **ID do contêiner**; **imagem** subjacente; **comando executado** quando o contêiner foi iniciado; **hora** em que ele foi iniciado e **status**.

Se você quiser que somente os contêineres atualmente em execução no sistema sejam exibidos, use a diretiva de linha de comando `docker ps`, sem adicionar nenhuma outra opção.

```none
$ sudo docker ps
```

No entanto, ao executar este comando logo após a instalação do Docker, é provável que nenhum contêiner esteja em execução no seu sistema.

#### Crie imagens Docker

Nosso tutorial Docker já ensinou como encontrar imagens no Docker Hub, assim como a baixá-las e executá-las com o Docker Engine. Mas além de acessar e utilizar registros disponibilizados pela plataforma e por terceiros, usuários também podem **criar imagens próprias** e compartilhá-las com outros desenvolvedores.

Você já aprendeu que cada imagem Docker é baseada em um ***Dockerfile***. O*Dockerfile*atua como um modelo de criação para imagens. Trata-se de um arquivo de texto simples, com todas as instruções que o Docker precisa para criar uma imagem. Nos passos a seguir, você aprenderá a escrever este tipo de*Dockerfile* e a instruir o Docker a utilizar sua escrita para criar uma nova imagem.

1. **Crie um novo diretório**: A equipe de desenvolvimento do Docker recomenda criar um diretório para cada *Dockerfile*. Diretórios podem ser criados com facilidade pelo terminal do Linux. Use o comando a seguir para criar um diretório com o nome *mydockerbuild*:

```none
$ mkdir mydockerbuild
```

[![Imagem: Comando mkdir no terminal do Ubuntu:](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/d/b/csm_DE-ubuntu-terminal-mkdir_0b91ca6517.webp "Comando mkdir no terminal do Ubuntu:")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-ubuntu-terminal-mkdir.png) Crie novos diretórios com o comando mkdir 2. **Navegue pelo novo diretório**: Use o comando `cd` para navegar pelo diretório recém-criado.

```none
$ cd mydockerbuild
```

[![Imagem: Comando cd no terminal do Ubuntu](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/f/d/csm_DE-ubuntu-terminal-cd_9928d40374.webp "Comando cd no terminal do Ubuntu")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-ubuntu-terminal-cd.png) Com a ajuda do comando cd, mude de diretório de trabalho 3. **Crie um novo arquivo de texto**: Você também pode criar arquivos de texto com facilidade pelo terminal do Ubuntu. Para fazer isso, use um editor de código, como Nano ou Vim. Crie um arquivo de texto com o nome *Dockerfile* no diretório *mydockerbuild*.

```none
$ nano Dockerfile
```

[![Imagem: Terminal do Ubuntu: crie arquivos de texto com o Nano](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/f/e/csm_DE-ubuntu-terminal-nano_033cfdf84b.webp "Terminal do Ubuntu: crie arquivos de texto com o Nano")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-ubuntu-terminal-nano.png) O editor de texto Nano vem pré-instalado em todas as versões do Ubuntu 4. **Escreva o *Dockerfile***: O arquivo de texto recém-criado servirá como base para a imagem a ser desenvolvida por você. Em vez de programar a imagem do zero, nosso tutorial Docker usará a imagem de demonstração*docker/whalesay*como modelo. Ela será integrada pelo comando `FROM` no*Dockerfile*. Use a*tag :latest* para apontar para a versão mais nova da imagem.

```none
FROM docker/whalesay:latest
```

Até o momento, você adicionou falas à baleia com o `docker/whalesay`. No terminal, o exato texto inserido por você foi exibido juntamente com o comando de inicialização do contêiner. Não seria mais interessante, contudo, se o próprio script gerasse o novo resultado de texto **automaticamente**? Isso pode ser feito! Use, por exemplo, o programa Furtunes, disponível em todos os sistemas Linux. A função básica do Fortunes é gerar frases estilo “sorte do dia” e ditados bem-humorados. Digite o comando abaixo para atualizar a indexação do seu pacote local e instalar o Fortunes:

```none
RUN apt-get -y update && apt-get install -y fortunes
```

Em seguida, defina uma declaração CMD. Ela deve ser executada após o comando `RUN`, a menos que tenha sido substituída pelo chamado (*docker run image CMD*). Use o comando abaixo para executar o programa Fortunes com a opção *-a* (selecionar de todos os bancos de dados) e exibir os resultados no terminal, usando o programa *cowsay*:

```none
CMD /usr/games/fortune -a | cowsay
```

Seu *Dockerfile* ficará assim:

```none
FROM docker/whalesay:latest
RUN apt-get -y update && apt-get install -y fortunes
CMD /usr/games/fortune -a | cowsay
```

Observação: Os **comandos** dentro de um *Dockerfile***sempre devem conter espaçamento simples** e começar com uma palavra-chave. Sua sintaxe não diferencia letras maiúsculas e minúsculas. No entanto, o uso consistente de maiúsculas nas palavras-chave se popularizou.

[![Imagem: Editor de texto Nano no terminal do Ubuntu](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/d/c/csm_DE-texteditor-nano-terminal_e5d92115d7.webp "Editor de texto Nano no terminal do Ubuntu")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-texteditor-nano-terminal.png) Controle o editor de texto Nano com as combinações de teclas sugeridas pelo rodapé 5. **Salve o arquivo de texto**: Salve sua entrada. Se estiver usando o editor Nano, use a combinação de teclas *CTRL* + *O* e confirme pressionando *ENTER*. O Nano informará que três linhas foram escritas no arquivo selecionado. Feche o editor de texto usando a combinação de teclas *CTRL* + *X*.
6. **Crie uma imagem como um *Dockerfile***: Para criar uma imagem a partir de um*Dockerfile*, navegue até o diretório onde o arquivo de texto está localizado. Inicie a criação da imagem com a diretiva de linha de comando `docker build`. Se quiser nomear individualmente a imagem ou atribuir uma*tag*a ela, use a opção-t, seguida pela combinação desejada de título e*tag*. O formato padrão é*nome:tag*.

Em nosso exemplo, uma imagem com o nome *docker-whale* será criada:

```none
$ docker build -t docker-whale .
```

O **ponto final** indica que o *Dockerfile* subjacente se encontra no diretório selecionado. Você também pode especificar um caminho ou URL para os arquivos de origem.

[![Imagem: Criação de imagem no terminal do Ubuntu](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/1/c/csm_De-imageerstellung-ubuntu-terminal_2c2efcf04b.webp "Criação de imagem no terminal do Ubuntu")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/De-imageerstellung-ubuntu-terminal.png) Criação de imagem com Docker build O processo *build* começa assim que o comando é confirmado, pressionando a tecla *ENTER*. Primeiro, o Docker *daemon* verifica se possui todos os arquivos que ele precisa para criar a imagem. Na terminologia Docker, isso é chamado de *context* (contexto). A seguinte mensagem de status é exibida no terminal:

```none
Sending build context to Docker daemon 2.048 kB
```

Em seguida, a imagem *docker/whalesay* com a tag: *latest* é localizada:

```none
Step 1/3 : FROM docker/whalesay:latest
    ---> 6b362a9f73eb
```

Se o contexto necessário para a criação da imagem já existir em totalidade, o Docker *daemon* iniciará o modelo de imagem anexado com o comando `FROM` em um contêiner temporário, e avançará para o próximo comando no *Dockerfile*. Em nosso exemplo, usamos o comando `RUN`, que faz com que o programa Fortunes seja instalado.

```none
Step 2 : RUN apt-get -y update && apt-get install -y fortunes
    ---> Running in 80b81eda1a11
…etc.
```

Ao final de cada passo do processo de criação de uma imagem, o Docker informa um **ID para a camada** que foi criada. Isso significa que cada linha no *Dockerfile* subjacente corresponde a uma camada da imagem nele construída.

Quando o comando `RUN` é concluído, o Docker *daemon* interrompe o contêiner criado, faz a remoção dele e inicia um novo contêiner temporário para a camada da declaração CMD.

```none
Step 3/3 : CMD /usr/games/fortune -a | cowsay
 ---> Running in c3ac46675e7a
 ---> 4419af61d32d
Removing intermediate container c3ac46675e7a
```

Ao final do processo de criação, o contêiner temporário criado no terceiro passo também é encerrado e removido. Finalmente, o Docker informará o ID da nova imagem:

```none
Successfully built 4419af61d32d
```

[![Imagem: Terminal do Ubuntu: mensagem de status durante a criação de uma imagem](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/e/7/csm_DE-ubuntu-statusmeldung-image_c836fb4166.webp "Terminal do Ubuntu: mensagem de status durante a criação de uma imagem")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-ubuntu-statusmeldung-image.png) As imagens Docker são criadas em múltiplas camadas A imagem recém-criada pode ser identificada pelo nome *docker-whale* na lista de imagens salvas localmente.

```none
$ sudo docker images
```

[![Imagem: Terminal do Ubuntu: lista de todas as imagens](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/6/3/csm_DE-ubuntu-terminal-uebersicht-images_5483113159.webp "Terminal do Ubuntu: lista de todas as imagens")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-ubuntu-terminal-uebersicht-images.png) A imagem recém-criada é exibida na lista de imagens Para iniciar um contêiner a partir da sua nova imagem, use a diretiva de linha de comando `sudo docker run` combinada com o nome da imagem:

```none
$ sudo docker run docker-whale
```

Se a imagem for criada corretamente pelo *Dockerfile*, sua baleia será uma fonte de inspiração, apresentando frases sábias espirituosas. Observação: sempre que você reiniciar o contêiner, uma nova frase será gerada.

[![Imagem: Contêiner baseado em docker-whale: resultado do texto no terminal](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/4/6/csm_DE-docker-whale-textausgabe_92d4dce03f.webp "Contêiner baseado em docker-whale: resultado do texto no terminal")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-docker-whale-textausgabe.png) Graças ao Fortunes, a baleia em ASCII compartilha frases espirituosas #### Atribua *tags* às imagens Docker e carregue-as no Docker Hub

Se você deseja carregar sua imagem *docker-whale* personalizada no Hub e disponibilizá-la à comunidade ou a um grupo de trabalho, primeiro é necessário vinculá-la a um repositório. Ele deverá ter o mesmo nome do seu próprio espaço de nomes. Na terminologia Docker, esta etapa é chamada de ***tagging***.

Para publicar uma imagem no Docker Hub, siga estes passos:

1. **Crie um repositório**: Acesse o Docker Hub usando seu Docker ID e sua senha pessoal. Em seguida, crie um repositório público com o nome *docker-whale*.

[![Imagem: Docker Hub: formulário para criação de repositório](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/3/4/csm_DE-docker-hub-erstellung-repo2_c82d769c9f.webp "Docker Hub: formulário para criação de repositório")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-docker-hub-erstellung-repo2.png) Crie um repositório para sua imagem personalizada 2. **Defina o ID da imagem**: Defina o ID da sua imagem *docker-whale* personalizada usando a diretiva de linha de comando `docker images`.

```none
$ sudo docker images
REPOSITORY		TAG	IMAGE ID		CREATED		SIZE
docker-whale		latest	4419af61d32d		22 hours ago		275 MB
hello-world		latest	48b5124b2768		6 weeks ago		1.84 kB
docker/whalesay	latest	6b362a9f73eb		21 months ago		247 MB
```

No nosso caso, o ID correspondente à imagem é *4419af61d32d*. Precisaremos dele no próximo passo do processo de *tagging*.

[![Imagem: Lista de todas as imagens locais no terminal do Ubuntu](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/8/3/csm_DE-ubuntu-terminal-uebersicht-images2_b4279d4935.webp "Lista de todas as imagens locais no terminal do Ubuntu")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-ubuntu-terminal-uebersicht-images2.png) O comando docker images exibe a lista de todas as imagens salvas no sistema 3. **Atribua uma *tag* à imagem**: Atribua uma *tag* à imagem *docker-whale* usando a linha de comando `docker tag` com o seguinte padrão:

```none
$ sudo docker tag [ID da imagem][Docker ID]/[Nome da imagem]:[TAG]
```

No exemplo do nosso tutorial Docker, a diretiva de linha de comando para *tagging* é a seguinte

```none
$ sudo docker tag 4419af61d32d myfreedockerid/docker-whale:latest
```

Você pode conferir se atribuiu a *tag* corretamente à sua imagem solicitando a lista de imagens do Docker. O nome do repositório passará a incluir seu Docker ID.

[![Imagem: Terminal do Ubuntu: lista das imagens antes e depois do processo de tagging](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/0/6/csm_DE-ubuntu-terminal-uebersicht-images-nach-tagging_3d707770ce.webp "Terminal do Ubuntu: lista das imagens antes e depois do processo de tagging")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-ubuntu-terminal-uebersicht-images-nach-tagging.png) Vincule imagens ao seu Docker ID usando o comando docker tag 4. **Envie a imagem**: Para enviar a imagem, você precisa acessar o Docker Hub usando sua conta. Isso pode ser feito pelo terminal, com o comando `docker login`.

```none
$ sudo docker login
```

O terminal solicitará que você insira seu nome de usuário (Docker ID) e senha.

[![Imagem: Acesso ao Docker Hub pelo terminal do Ubuntu](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/d/b/csm_DE-ubuntu-terminal-docker-anmeldung_9e2acd70a4.webp "Acesso ao Docker Hub pelo terminal do Ubuntu")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-ubuntu-terminal-docker-anmeldung.png) Antes de enviar uma imagem ao Docker Hub, você precisa acessar sua conta Se o acesso for bem-sucedido, use a diretiva de linha de comando `push` para enviar sua imagem ao repositório recém-criado.

```none
$ sudo docker push myfreedockerid/docker-whale
```

O processo de envio deve levar apenas alguns segundos. O status é informado no terminal.

[![Imagem: Terminal do Ubuntu: mensagem de status do envio da imagem](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/d/b/csm_DE-ubuntu-terminal-statusmeldung-nach-upload_a245c839c6.webp "Terminal do Ubuntu: mensagem de status do envio da imagem")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-ubuntu-terminal-statusmeldung-nach-upload.png) Após o envio, a imagem ficará disponível no grupo tag latest do Docker Hub Acesse o Docker Hub pelo navegador para visualizar a imagem enviada.

[![Imagem: Docker Hub: visão detalhada do repositório myfreedockerid docker-whale](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/2/4/csm_DE-docker-hub-myfreedockerid-detail_b096c8e62b.webp "Docker Hub: visão detalhada do repositório myfreedockerid docker-whale")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-docker-hub-myfreedockerid-detail.png) A última atualização do seu repositório será exibida na visão detalhada Se você quiser enviar mais de uma imagem por repositório, use *tags* diversificadas para disponibilizar suas imagens em versões diferentes. Por exemplo:

```none
$ sudo docker images
REPOSITORY       TAG    IMAGE ID      CREATED       SIZE
docker-whale     latest 4419af61d32d  22 hours ago  275 MB
hello-world      latest 48b5124b2768  6 weeks ago   1.84 kB
docker/whalesay  latest 6b362a9f73eb  21 months ago 247 MB
```

Uma visão geral das diversas versões da imagem é exibida no repositório do Docker Hub, na aba “Tags”.

[![Imagem: Docker Hub: aba Tags](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/d/1/csm_DE-docker-hub-tags_06a78b89db.webp "Docker Hub: aba Tags")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-docker-hub-tags.png) Na aba Tags, você encontra todas as versões de uma imagem; fonte: hub.docker.com No entanto, imagens de projetos diferentes devem ser disponibilizadas em repositórios distintos.

Se o envio for bem-sucedido, sua imagem personalizada estará disponível no repositório público a todos os usuários de Docker ao redor do mundo.

5. **Execute um teste**: Efetue o download da imagem teste para checar se o envio foi bem-sucedido.

Observe que a versão local da imagem precisa ser excluída antes que o download de uma nova cópia com a mesma *tag* seja realizado. Do contrário, o Docker informará que a imagem desejada já existe em versão atualizada.

[![Imagem: Mensagem de status: Image is up to date](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/3/6/csm_DE-ubuntu-image-is-up-to-date_371f5fb873.webp "Mensagem de status: Image is up to date")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-ubuntu-image-is-up-to-date.png) Se a imagem já existir localmente, o comando pull será cancelado Para excluir uma imagem Docker localmente, use o comando `docker rmi` combinado com o respectivo ID da imagem. Como de costume, isso deve ser feito por meio do Docker Images. Se o Docker registrar um conflito (por exemplo, se o ID de uma imagem estiver sendo usado em múltiplos repositórios ou em um contêiner), reitere o comando com a opção *--force* ou *-f* (forma abreviada), para **forçar sua exclusão**.

```none
sudo docker rmi -f 4419af61d32d
```

[![Imagem: Comando docker rmi combinado à opção -f force](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/a/a/csm_De-docker-rmi-force_1edcd2a03c.webp "Comando docker rmi combinado à opção -f force")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/De-docker-rmi-force.png) Use o comando docker rmi combinado à opção -f para forçar uma exclusão Exiba a lista de todas as imagens locais novamente:

```none
$ sudo docker Images
```

Os elementos excluídos não devem mais ser exibidos pelo terminal. Use o comando `pull` no repositório para fazer o download de uma **nova cópia da imagem** pelo Docker Hub.

```none
$ sudo docker pull myfreedockerid/docker-whale
```

[![Imagem: Terminal do Ubuntu: download pelo Docker Hub](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/d/8/csm_DE-ubuntu-terminal-download-docker-hub_025b83156d.webp "Terminal do Ubuntu: download pelo Docker Hub")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots/DE-ubuntu-terminal-download-docker-hub.png) O download da imagem publicada foi realizado com sucesso ## De iniciantes a profissionais em Docker

Neste tutorial Docker, mostramos que a plataforma de contêineres se difere da tradicional virtualização de hardware em vários aspectos fundamentais. O Docker conta com contêineres softwares e, por isso, evita a sobrecarga do sistema operacional virtual convidado. Os contêineres compartilham o núcleo do mesmo *host* e geram tudo o que é necessário para executar aplicações como processos isolados no espaço de usuário. O resultado é **portabilidade máxima**. Com o Docker, um único contêiner software pode ser executado em diversas plataformas e em vários sistemas e infraestruturas. Requisitos são somente: instalação local do Docker Engine e acesso ao Docker Hub baseado em nuvem.

Nosso exemplo demonstrou como é rápido implementar uma plataforma de contêineres plenamente funcional no Ubuntu — uma popular distribuição Linux — usando o Docker. Você aprendeu a instalar e configurar o Docker no Ubuntu, fazer o download de aplicações como imagens pelo Docker Hub e executá-las localmente em contêineres. Você escreveu um *Dockerfile*, criou sua própria imagem e a disponibilizou a outros usuários de Docker por meio do serviço em nuvem. Resumindo: você se familiarizou com o **básico da plataforma de contêineres**.

Não se esqueça, porém, que o universo Docker é gigantesco. Com o passar do tempo, o proeminente projeto de código aberto se transformou em um **[ecossistema Docker](https://www.ionos.com/pt-br/digitalguide/servidor/conhecimento/docker-tools-principais-ferramentas-docker/ "Ferramentas Docker: Ecossistema da plataforma de contêineres")** vivo. Devido ao seu sucesso, diversos concorrentes tentam emplacar [alternativas ao Docker](https://www.ionos.com/digitalguide/server/know-how/docker-alternatives-at-a-glance/ "Alternativas ao Docker") no mercado. O Docker é uma opção interessante para administradores, especialmente aos que operam aplicações complexas, com múltiplos contêineres paralelos, em sistemas diferentes. A solução também oferece diversas funções para a [**orquestração** de contêineres, com Swarm e Compose](https://www.ionos.com/digitalguide/server/know-how/docker-orchestration-with-swarm-and-compose/ "Orquestração no Docker com Swarm e Compose").


This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/servidor/configuracao/tutorial-docker/](https://www.ionos.com/pt-br/digitalguide/servidor/configuracao/tutorial-docker/) for AI/LLM consumption.