codigo35.com

Docker para Desenvolvedores

Se você é um entusiasta da programação ou está iniciando sua jornada, certamente já sentiu falta de um material sobre Docker para Desenvolvedores.

Este artigo é mais do que uma introdução; é um convite para explorar os benefícios e as transformações que o Docker trouxe para o desenvolvimento de aplicações.

Ao mergulharmos nas águas dos contêineres, imagens e eficiência no desenvolvimento moderno, descubra como o Docker se tornou a ferramenta essencial para garantir consistência e agilidade em todas as fases do ciclo de vida do software. Vamos la!

Você encontra nesse post mostrar

O que é o Docker

Docker é uma plataforma de virtualização leve e eficiente que simplifica o desenvolvimento, implantação e execução de aplicações por meio de containers.

Containers são ambientes isolados que incluem todos os recursos necessários para executar uma aplicação, como bibliotecas, dependências e configurações, garantindo consistência entre ambientes de desenvolvimento e produção.

Utilizando tecnologias de virtualização a nível de sistema operacional, 👉 o Docker permite que desenvolvedores empacotem e distribuam suas aplicações de forma padronizada, facilitando a escalabilidade e a gestão de infraestrutura. Isso proporciona benefícios como portabilidade, eficiência no consumo de recursos e rapidez no deploy, tornando o Docker uma ferramenta essencial para a modernização e agilidade do ciclo de vida de desenvolvimento de software.

Historia do Docker

Solomon Hykes, fonte: Crunchbase

A criação do Docker não foi uma casualidade, mas sim o resultado de uma jornada intensa de muito trabalho. Em 2013, em São Francisco, a empresa Docker, Inc. fundada por Solomon Hykes lançou ao mundo uma ferramenta que mudaria como desenvolvemos software.

Solomon Hykes, nascido na França, liderou uma equipe de desenvolvedores com um background técnico diversificado. Entre eles estavam especialistas em sistemas distribuídos, virtualização e automação.

O Docker foi concebido como uma resposta direta à dor sentida por desenvolvedores ao lidar com a migração de aplicações entre diferentes ambientes. Ao incorporar tecnologias como o Linux Containers (LXC), os criadores do Docker conseguiram fornecer uma solução elegante para encapsular aplicações e suas dependências.

Antes do Docker, os desenvolvedores frequentemente enfrentavam o desafio de “Isso funciona na minha máquina, mas não no servidor” 😬. A ferramenta surgiu como um remédio para essa dor, permitindo que aplicações fossem empacotadas com todas as suas dependências, garantindo consistência em qualquer ambiente.

O que são Containers?

Em termos simples, um container é uma unidade leve e autossuficiente que pode executar uma aplicação e suas dependências de forma isolada. Diferente das máquinas virtuais, os containers compartilham o kernel do sistema operacional do host, resultando em maior eficiência e velocidade. Ao utilizar recursos como namespaces e cgroups do Linux, os containers conseguem criar ambientes isolados, proporcionando consistência em diferentes ambientes de execução.

Vantagens dos Containers

A popularidade dos containers reside nas vantagens que oferecem ao desenvolvimento de software. A portabilidade é uma delas; um container pode ser executado de maneira consistente em qualquer ambiente que suporte a tecnologia, eliminando a famosa frase “Na minha máquina funciona”.

Além disso, a escalabilidade é simplificada, permitindo que aplicações sejam rapidamente replicadas e dimensionadas conforme a demanda, sem a necessidade de configurar complexas infraestruturas.

O que são Imagens Docker?

As imagens Docker desempenham um papel crucial para os containers, sendo a espinha dorsal que permite aos desenvolvedores empacotar e distribuir suas aplicações com facilidade. 

Uma imagem Docker é um pacote que contém tudo o que é necessário para executar uma aplicação, incluindo o código, as bibliotecas, as dependências e as configurações 🤩.

Utilizando um formato padronizado, as imagens são construídas a partir de um arquivo chamado Dockerfile, que descreve passo a passo como a imagem deve ser configurada. Essa abordagem padronizada facilita a criação de ambientes de desenvolvimento consistentes e reproduzíveis.

Reusabilidade e Eficiência

A grande vantagem das imagens Docker é a capacidade de reutilização. Uma vez que uma imagem é construída, ela pode ser compartilhada através do Docker Hub ou outros registros, permitindo que outros desenvolvedores a utilizem em seus projetos.

Essa reusabilidade não apenas acelera o desenvolvimento, mas também garante que todos os membros da equipe estejam trabalhando em um ambiente idêntico, evitando inconsistências e surpresas desagradáveis durante um deploy.

Implantação e Escalabilidade

Ao criar uma aplicação, os desenvolvedores podem pensar nas imagens Docker como fotografias do ambiente de execução.

Além disso, quando combinadas com orquestradores de containers como o Kubernetes, as imagens Docker facilitam o scaling, permitindo que aplicações se expandam ou se contraiam conforme a demanda, sem a necessidade de configurações complexas.

O que é Dockerfile?

No universo do Docker, o Dockerfile é uma peça-chave que permite aos desenvolvedores criar imagens personalizadas de containers de forma eficiente.

Definição e Funcionamento

Um Dockerfile é um arquivo de script que contém um conjunto de instruções para a construção de uma imagem Docker específica.

Cada linha no Dockerfile representa uma etapa no processo de criação da imagem, desde a escolha da imagem base até a configuração das dependências e a definição do ambiente de execução. Essa abordagem baseada em scripts proporciona consistência, reprodutibilidade e facilidade na criação de ambientes isolados para as aplicações.

Estrutura e Instruções Básicas

A estrutura de um Dockerfile é direta, composta por uma série de instruções que são executadas sequencialmente. Inicia-se com a escolha de uma imagem base usando a instrução FROM, seguida por comandos para instalação de dependências (RUN), definição de variáveis de ambiente (ENV), exposição de portas (EXPOSE), entre outras.

Cada instrução contribui para a configuração específica da imagem, garantindo que a aplicação seja executada da maneira desejada.

👉 Exemplo de um Dockerfile de uma aplicação React:

# Usando uma imagem oficial do Node.js como base
FROM node:14-alpine

# Definindo o diretório de trabalho dentro do contêiner
WORKDIR /app

# Copiando os arquivos de package.json e package-lock.json para o diretório de trabalho
COPY package*.json ./
RUN npm install --silent
RUN npm install react-scripts -g --silent

# Copiando todos os arquivos do diretório atual para o diretório de trabalho
COPY . .

# Expondo a porta 3000, que é a porta padrão usada pelo servidor de desenvolvimento do React
EXPOSE 3000

# Comando para iniciar a aplicação quando o contêiner for executado
CMD ["npm", "start"]

Explicando o que cada linha faz:

Comando DockerDescrição
FROM node:14-alpineDefine a imagem base para o Dockerfile, utilizando uma imagem oficial do Node.js na versão 14 com a distribuição Alpine, que é uma versão leve do sistema operacional.
WORKDIR /appEstabelece o diretório de trabalho dentro do container como “/app”, onde serão realizadas as operações subsequentes.
COPY package*.json ./Copia os arquivos package.json e package-lock.json do diretório de compilação local para o diretório de trabalho dentro do container (“/app”).
RUN npm install --silentExecuta o comando npm install para instalar as dependências do projeto. O parâmetro --silent é utilizado para suprimir a saída detalhada durante o processo de instalação.
RUN npm install react-scripts -g --silentInstala globalmente o pacote react-scripts para facilitar o desenvolvimento com React. O parâmetro -g indica a instalação global, e --silent é usado para reduzir a saída verbosa do npm.
COPY . .Copia todos os arquivos do diretório local para o diretório de trabalho dentro do container (“/app”). Este comando é utilizado para adicionar o restante dos arquivos do projeto ao container.
EXPOSE 3000Informa ao Docker que o container estará escutando na porta 3000 durante a execução. Embora isso não publique a porta automaticamente, é uma convenção que auxilia na documentação sobre quais portas a aplicação dentro do container usará.
CMD ["npm", "start"]Especifica o comando padrão a ser executado quando o container for iniciado. Neste caso, inicia a aplicação React usando o comando npm start.

Vantagens e Personalização

A principal vantagem do Dockerfile é a capacidade de personalizar imagens de containers conforme as necessidades do desenvolvedor ou da aplicação. 🤓

Ao criar um Dockerfile, os desenvolvedores podem automatizar o processo de construção de imagens, tornando-o repetível e fácil de entender. Essa personalização não apenas facilita a criação de ambientes consistentes, mas também acelera o desenvolvimento, permitindo que as equipes compartilhem e repliquem configurações de forma eficiente.

Integração e Melhores Práticas

Para otimizar o uso do Dockerfile, é fundamental incorporar boas práticas, como:

O que é Docker Compose?

O Docker Compose é uma ferramenta que permite definir e gerenciar configurações multi-container de forma declarativa, usando um arquivo YAML.

Sua principal função é fornecer uma maneira eficiente de definir, executar e escalar aplicativos compostos por vários serviços, garantindo que todos os containers interajam de maneira harmoniosa.

Ao invés de lidar com diversos comandos individuais do Docker, o Docker Compose consolida todas as configurações em um único arquivo, simplificando a gestão de aplicações complexas.

Estrutura e Configuração

O Docker Compose utiliza um arquivo chamado docker-compose.yml, que descreve os serviços, redes e volumes necessários para a aplicação. Nesse arquivo, os desenvolvedores podem definir parâmetros como imagens do container, portas expostas, variáveis de ambiente e relações entre os serviços.

A estrutura clara e legível do YAML torna o arquivo de composição acessível, permitindo que os desenvolvedores visualizem e modifiquem facilmente as configurações do aplicativo.

Exemplo de docker-compose.yml de uma aplicação Go que também levanta um serviço de banco de dados Mongo:

version: '3'

services:
  # Serviço da aplicação Go
  app:
    image: golang:1.17-alpine
    container_name: minha-aplicacao-go
    working_dir: /go/src/app
    volumes:
      - .:/go/src/app
    ports:
      - "8080:8080"
    command: go run main.go

  # Serviço do banco de dados MongoDB
  mongo:
    image: mongo:latest
    container_name: meu-mongodb
    ports:
      - "27017:27017"
    environment:
      MONGO_INITDB_ROOT_USERNAME: usuario
      MONGO_INITDB_ROOT_PASSWORD: senha
      MONGO_INITDB_DATABASE: minha-base-de-dados

Explicando o que cada linha do arquivo acima faz:

Comando Docker ComposeDescrição
version: '3'Especifica a versão do formato do arquivo Docker Compose. Neste caso, utiliza a versão 3.
services:Indica o início da seção de serviços, onde os serviços que compõem a aplicação são definidos.
app:Define o serviço chamado “app”, que representa a aplicação Go.
image: golang:1.17-alpineEspecifica a imagem a ser usada para o serviço “app”. Neste caso, utiliza a imagem oficial do Golang na versão 1.17 com a distribuição Alpine, que é uma versão leve do sistema operacional.
container_name: minha-aplicacao-goAtribui o nome “minha-aplicacao-go” ao container que será criado para o serviço “app”.
working_dir: /go/src/appDefine o diretório de trabalho dentro do container para “/go/src/app”. Este é o diretório onde o código-fonte da aplicação Go será montado.
volumes: - .:/go/src/appConfigura o volume para montar o código-fonte local (do diretório onde o arquivo docker-compose.yml está localizado) no diretório de trabalho dentro do container. Isso permite que as alterações no código local sejam refletidas no contêiner sem a necessidade de reconstruir a imagem.
ports: - "8080:8080"Mapeia a porta 8080 do host para a porta 8080 do container para permitir o acesso à aplicação Go.
command: go run main.goEspecifica o comando a ser executado quando o contêiner for iniciado. Neste caso, utiliza o comando go run main.go para iniciar a aplicação Go.
mongo:Define o serviço chamado “mongo”, que representa o banco de dados MongoDB.
image: mongo:latestEspecifica a imagem oficial mais recente do MongoDB a ser usada para o serviço “mongo”.
container_name: meu-mongodbAtribui o nome “meu-mongodb” ao container que será criado para o serviço “mongo”.
ports: - "27017:27017"Mapeia a porta 27017 do host para a porta 27017 do container para permitir o acesso ao MongoDB.
environment: ...Define variáveis de ambiente específicas para o MongoDB, como o nome de usuário, senha e nome do banco de dados. Essas variáveis são utilizadas durante a inicialização do MongoDB no container.

Como o Docker funciona

O processo de criação de containers no Docker começa com a definição de um Dockerfile. Este arquivo contém as instruções para configurar um ambiente específico, incluindo a escolha da imagem base, a instalação de dependências e a configuração do ambiente de execução.

O Dockerfile serve como um guia, permitindo que desenvolvedores descrevam o ambiente desejado de forma declarativa.

Ao executar o comando docker build, o Docker utiliza o Dockerfile para construir uma imagem. Essa imagem é uma fotografia autossuficiente que contém a aplicação e todas as suas dependências. O processo é eficiente e rápido devido à tecnologia de camadas, que aproveita imagens existentes para evitar a duplicação de recursos durante a construção.

Isolamento e Eficiência

Uma vez que a imagem é criada, ela pode ser transformada em um container em execução com o comando docker run. Os containers Docker oferecem isolamento eficiente, compartilhando o kernel do sistema operacional do host, mas mantendo processos, redes e sistemas de arquivos independentes.

👉 Isso resulta em uma execução mais leve e eficiente em comparação com máquinas virtuais tradicionais.

Os containers Docker também aproveitam tecnologias do kernel do Linux, como namespaces e cgroups, para criar ambientes isolados. Isso significa que processos em um container não interfere com os processos em outros containers ou no host, proporcionando consistência e previsibilidade.

Orquestração e Escalabilidade

Para gerenciar aplicações compostas por vários containers, o Docker permite a integração com ferramentas de orquestração, como o Docker Compose, Docker Swarm e Kubernetes.

Essas ferramentas simplificam a implantação e o dimensionamento de aplicações, permitindo que desenvolvedores definam a configuração de toda a aplicação em um único arquivo.

Ao integrar-se a essas ferramentas, o Docker facilita a escalabilidade automática, possibilitando que aplicações se expandam ou contraiam conforme a demanda em produção. Isso é essencial para lidar com picos de tráfego e garantir o desempenho consistente de aplicações em ambientes dinâmicos.

Docker e Kubernetes: quais as diferenças?

Docker e Kubernetes são duas ferramentas fundamentais no universo da contêinerização e orquestração de aplicações. Embora estejam interligados, desempenham papéis distintos, complementando-se para oferecer uma solução completa. 

✅ Diferenças na Abordagem

✅ Diferenças na Escala e Complexidade

✅ Trabalhando com Docker e Kubernetes

O Docker é pago?

Em sua essência, o Docker oferece uma base sólida de forma gratuita. Os recursos essenciais para criar, distribuir e executar containers estão disponíveis sem custos para desenvolvedores individuais e estudantes.

O Modelo Freemium do Docker

Entretanto, como muitas tecnologias modernas, o Docker adota um modelo freemium para atender às diversas necessidades de seus usuários.

Isso significa que, enquanto a versão básica é gratuita, há opções de planos pagos que oferecem recursos avançados e suporte especializado. Esses planos são projetados para atender às demandas de empresas e organizações com requisitos mais complexos.

Planos Pagos e Vantagens Adicionais

Ao optar por um plano pago do Docker, as organizações podem desfrutar de benefícios como suporte técnico prioritário, gerenciamento avançado de imagens e recursos de segurança adicionais.

Essas características são cruciais em ambientes de produção, onde a estabilidade, a segurança e o suporte técnico têm papel fundamental.

Comandos essenciais do Docker

Dominar os comandos mais úteis do Docker é crucial para desenvolvedores, pois oferece uma habilidade fundamental para resolver desafios diários.

Esses comandos proporcionam controle sobre a criação, execução e gestão de containers, permitindo a rápida resolução de problemas, desde a construção e implantação até a monitorização e depuração.

Resumimos abaixo os 10 comandos mais úteis do Docker para o dia-a-dia do desenvolvedor. Para navegar rapidamente entre eles, use os links abaixo:

docker rundocker build
docker psdocker exec
docker start e stopdocker compose up e down
docker imagesdocker pull
docker networkdocker logs
10 comandos mais úteis do Docker para o dia-a-dia

docker run

O comando docker run é fundamental no ecossistema Docker, permitindo a execução de containers com base em imagens previamente construídas. Com essa instrução, os desenvolvedores podem transformar uma imagem Docker em um container funcional, pronto para executar sua aplicação.

Exemplo de uso

Digamos que você tenha uma imagem Docker para uma aplicação web em Node.js chamada “minha-app-node”. Para iniciar um container usando essa imagem, você utilizaria o seguinte comando docker run:

docker run --name meu-container-web -p 8080:3000 minha-app-node

Neste exemplo:

  • --name meu-container-web atribui um nome personalizado ao container para fácil referência.
  • -p 8080:3000 mapeia a porta 8080 do seu computador (host) para a porta 3000 dentro do container, permitindo acesso à aplicação web.
  • minha-app-node é o nome da imagem Docker que será utilizada.

Ao executar esse comando, você receberá um ID de container, indicando que o container foi iniciado com sucesso. O ID pode ser utilizado para acessar logs, parar ou reiniciar o container.

Além disso, se a aplicação web estiver configurada corretamente, você poderá acessá-la no navegador através da porta mapeada (por exemplo, http://localhost:8080).

Exemplo de output:

5d3d6472b54a1f3c36b41e5e5fb1a83d0a2d9e18f1a3d55c1e77b4e9e08a7e1a

docker build

O comando docker build também é crucial no processo de criação de imagens Docker personalizadas.

Ele permite que os desenvolvedores convertam suas configurações e dependências em uma imagem Docker, tornando-a pronta para ser usada na criação de containers.

Exemplo de uso

Suponha que você tenha um Dockerfile em seu diretório de projeto e deseja construir uma imagem Docker chamada “minha-imagem-app”. O comando docker build seria utilizado da seguinte forma:

docker build -t minha-imagem-app .

Neste exemplo:

  • -t minha-imagem-app atribui um nome à imagem resultante.
  • . indica que o Docker deve procurar o Dockerfile no diretório atual.

Ao executar o comando, o Docker inicia o processo de construção, seguindo as instruções do Dockerfile.

Durante a execução, cada etapa é exibida no terminal, mostrando o progresso. Se o processo for concluído com sucesso, você receberá o ID da imagem resultante.

Exemplo de output:

Successfully built 3a177a1ab3cd

O ID da imagem pode ser usado posteriormente para referenciar ou compartilhar a imagem construída.

docker ps

O comando docker ps permite aos desenvolvedores visualizar os containers em execução no sistema. Esse comando fornece uma visão instantânea do estado atual dos containers, exibindo informações essenciais como ID, nomes, portas expostas e tempo de execução.

Exemplo de uso

Para listar todos os containers em execução no sistema, o comando docker ps é utilizado da seguinte forma:

docker ps

Caso deseje visualizar todos os containers, incluindo os que estão parados, o seguinte comando pode ser utilizado:

docker ps -a

O output do comando docker ps apresenta uma tabela com informações detalhadas dos containers em execução. Um exemplo simplificado de output pode ser:

CONTAINER ID   IMAGE        COMMAND            CREATED        STATUS       PORTS                   NAMES

4a3e8a285e12   nginx:latest "nginx -g 'daemon…"   5 minutes ago  Up 5 minutes   0.0.0.0:8080->80/tcp   web-server

Neste exemplo:

  • CONTAINER ID é o identificador único do container.
  • IMAGE indica a imagem utilizada para criar o container.
  • COMMAND mostra o comando sendo executado dentro do container.
  • CREATED exibe o tempo decorrido desde a criação do container.
  • STATUS mostra o estado atual do container (em execução, parado, etc.).
  • PORTS lista as portas mapeadas entre o host e o container.
  • NAMES atribui um nome legível ao container.

docker exec

O comando docker exec permite que os desenvolvedores executem comandos dentro de um container em execução.

Essa funcionalidade é importante para interagir diretamente com aplicações em container, facilitando tarefas de manutenção, depuração e personalização em tempo real.

Exemplo de uso

Para executar um comando dentro de um container, o comando docker exec é utilizado da seguinte forma:

docker exec -it meu-container bash

Neste exemplo:

  • -it permite a interação no modo terminal.
  • meu-container é o nome ou ID do container alvo.
  • bash é o comando que será executado dentro do container. Nesse caso, queremos acessar o shell.

O output do comando docker exec mostra a execução do comando dentro do container, permitindo a interação direta com o ambiente do container.

Não há um output padrão do comando docker exec, pois isso depende do comando específico que foi executado.

No entanto, uma vez dentro do container, você pode visualizar ou modificar arquivos, instalar pacotes, verificar logs e realizar outras ações necessárias para o desenvolvimento ou manutenção.

docker start e docker stop

Os comandos docker start e docker stop são ferramentas essenciais no kit de comandos do Docker, permitindo que os desenvolvedores controlem o ciclo de vida dos containers. O docker start inicia um container previamente criado e parado, enquanto o `docker stop` interrompe a execução de um container em execução de maneira segura.

Exemplo de uso do docker start

Para iniciar um container que foi previamente parado, o comando docker start é utilizado da seguinte forma:

docker start meu-container

Neste exemplo:

  • meu-container é o nome ou ID do container que se deseja iniciar.

O output do comando docker start será o ID do container iniciado, indicando que o processo foi concluído com sucesso.

meu-container
Exemplo de uso do docker stop

Para interromper a execução de um container de maneira segura, o comando docker stop é utilizado:

docker stop meu-container

Neste exemplo:

  • meu-container é o nome ou ID do container que se deseja parar.

O output do comando docker stop não gera uma saída padrão, mas o container será interrompido e pode ser verificado utilizando o comando docker ps para confirmar que não está mais em execução.

docker-compose up e docker-compose down

Os comandos docker-compose up e docker-compose down são o “docker start/stop”, porém no mundo do Docker-Compose.

Eles facilitam a execução e parada aplicações compostas por vários containers. O docker-compose up inicia os serviços definidos no arquivo docker-compose.yml, enquanto o docker-compose down encerra esses serviços de maneira ordenada.

Exemplo de uso do docker-compose up

Para iniciar os serviços definidos em um arquivo docker-compose.yml, o comando docker-compose up é utilizado da seguinte forma:

docker-compose up

Este comando deve ser executado no diretório onde o arquivo docker-compose.yml está localizado. Ele iniciará todos os serviços configurados no arquivo.

O output do comando docker-compose up mostrará logs dos serviços iniciados.

Cada serviço terá sua própria saída de log, indicando que foi iniciado com sucesso. Você verá mensagens indicando que os containers estão em execução.

Exemplo de uso do docker-compose down

Para encerrar os serviços definidos no arquivo docker-compose.yml, o comando docker-compose down é utilizado:

docker-compose down

Assim como o docker-compose up, este comando deve ser executado no diretório onde o arquivo docker-compose.yml está localizado. Ele interromperá e removerá todos os containers e redes associados aos serviços definidos.

O output do comando docker-compose down mostrará mensagens indicando que os containers foram parados e removidos com sucesso.

Exemplo de output:

Stopping meu-servico      ... done

Removing meu-servico      ... done

docker images

O comando docker images é a ferramenta para os desenvolvedores gerenciarem e visualizarem as imagens disponíveis em seus sistemas Docker.

Ele fornece uma lista clara e detalhada das imagens presentes localmente, facilitando o entendimento das versões, tamanhos e outras informações importantes.

Exemplo de uso

Para listar todas as imagens presentes no sistema, o comando docker images é utilizado da seguinte forma:

docker images

Este comando exibirá uma tabela que inclui informações como o repositório da imagem, a tag (versão), o ID da imagem, o tamanho e a data de criação.

O output do comando docker images se parece com o seguinte:

REPOSITORY     TAG       IMAGE ID       CREATED         SIZE

nginx          latest    abcd1234efgh   2 days ago      132MB

my-app         v1.0      xyz5678ijkl   1 week ago      300MB

Neste exemplo:

  • REPOSITORY indica o nome do repositório da imagem.
  • TAG é a versão da imagem (tag).
  • IMAGE ID é o identificador único da imagem.
  • CREATED mostra a data de criação da imagem.
  • SIZE representa o tamanho total da imagem.

docker pull

O comando docker pull permite que os desenvolvedores baixem imagens de containers de repositórios remotos para uso local.

Essa ação é essencial para obter as últimas versões de imagens ou adquirir imagens específicas necessárias para o desenvolvimento.

Exemplo de uso

Para baixar uma imagem específica de um repositório remoto, o comando docker pull é utilizado da seguinte forma:

docker pull nginx:latest

Neste exemplo:

  • nginx é o nome da imagem
  • latest é a tag (versão) da imagem. Se não especificado, o Docker assume automaticamente a versão mais recente.

O output do comando docker pull mostra o progresso do download, indicando quando a imagem foi baixada com sucesso. Se a imagem já estiver presente localmente, o Docker verificará se a versão mais recente está disponível e, se necessário, fará o download.

Exemplo de output:

latest: Pulling from library/nginx

5c90d4a2d1a8: Pull complete

7c3d31739525: Pull complete

4a8b42f9ad87: Pull complete

Digest: sha256:abcd1234efghijklmnopqrstuvwxyz

Status: Downloaded newer image for nginx:latest

docker network

O comando docker network permite criar, gerenciar e visualizar redes para conectar containers.

Esse comando é importante para estabelecer a comunicação entre containers em diferentes serviços, proporcionando uma infraestrutura de rede adequada para a aplicação.

Exemplo de uso

Para listar as redes disponíveis no sistema, o comando docker network é utilizado da seguinte forma:

docker network ls

Este comando exibirá uma lista de redes, mostrando informações como ID, nome, driver da rede e escopo (local ou global).

O output do comando docker network ls se parecer com o seguinte:

NETWORK ID     NAME            DRIVER    SCOPE

abcdef123456   bridge          bridge    local

ghijkl789012   host            host      local

mnopqr345678   my-network      bridge    local

Neste exemplo:

  • NETWORK ID é o identificador único da rede.
  • NAME é o nome atribuído à rede.
  • DRIVER é o driver de rede utilizado.
  • SCOPE indica se a rede é local ou global.

Outros comandos, como docker network create e docker network connect, são usados para criar novas redes ou conectar containers a redes existentes.

docker logs

O comando docker logs possibilita os desenvolvedores visualizar os logs de saída de um container em execução.

Essa funcionalidade é essencial para monitorar e depurar aplicações, fornecendo insights sobre o comportamento interno dos containers.

Exemplo de uso

Para visualizar os logs de saída de um container específico, o comando docker logs é utilizado da seguinte forma:

docker logs meu-container

Neste exemplo:

  • meu-container é o nome ou ID do container do qual se deseja visualizar os logs.

O output do comando docker logs exibirá os logs de saída do container. Isso pode incluir mensagens de inicialização, erros, saída padrão de aplicativos e outras informações relevantes.

Exemplo de output:

2023-01-15T10:30:00.000Z: Info: Aplicação iniciada com sucesso.

2023-01-15T10:35:00.000Z: Error: Conexão com o banco de dados falhou.

2023-01-15T10:40:00.000Z: Warn: Volume de solicitações HTTP aumentou.

Como rodar sua aplicação via Docker

Adaptar uma aplicação para rodar no Docker envolve alguns passos para tudo funcionar. Montamos um guia resumido dos principais pontos:

😎 Sabemos que cada aplicação tem necessidades específicas, então certifique-se de ajustar os detalhes conforme necessário.

Para ajudar nesse processo, nós listamos alguns casos comuns de tecnologias específicas usando Docker. Vamos lá!

Docker com Python

Vamos criar uma aplicação Python simples que utiliza a calcula a sequência de Fibonacci para um número informado pelo usuário.

Exemplo de aplicação Python

Código do arquivo fibonacci.py:

# fibonacci.py
def fibonacci(n):
    if n <= 0:
        return "Número inválido. Forneça um número inteiro positivo."
    elif n == 1:
        return [0]
    elif n == 2:
        return [0, 1]
    else:
        fib_sequence = [0, 1]
        while len(fib_sequence) < n:
            fib_sequence.append(fib_sequence[-1] + fib_sequence[-2])
        return fib_sequence

if __name__ == "__main__":
    number = int(input("Digite um número para calcular a sequência de Fibonacci: "))
    result = fibonacci(number)
    print(f"A sequência de Fibonacci para o número {number} é: {result}")

Código do arquivo Dockerfile:

# Dockerfile
# Use a imagem oficial do Python como base
FROM python:3.9-slim

# Defina o diretório de trabalho dentro do contêiner
WORKDIR /app

# Copie o código Python para o diretório de trabalho
COPY fibonacci.py .

# Comando para executar a aplicação ao rodar o contêiner
CMD ["python", "fibonacci.py"]

Para executar essa aplicação com Docker, siga estas etapas:

  • Salve o código Python acima em um arquivo chamado fibonacci.py.
  • Crie um arquivo chamado Dockerfile com o conteúdo acima.
  • Abra um terminal e navegue até o diretório que contém esses dois arquivos.
  • Execute o seguinte comando para construir a imagem Docker:
docker build -t fibonacci-app .
  • Após a construção, execute o container:
   docker run -it fibonacci-app
  • O programa solicitará que você insira um número para calcular a sequência de Fibonacci.

Docker com Django

A aplicação Django abaixo é a mais simples possível: um “Olá Mundo”. Nesse exemplo mostramos a estrutura da app e seu Dockerfile:

Exemplo de aplicação Django

Código do arquivo views.py:

from django.http import HttpResponse
from django.shortcuts import render

def hello_world(request):
    return HttpResponse("Olá Mundo")

Código do arquivo urls.py:

from django.urls import path
from .views import hello_world

urlpatterns = [
    path('', hello_world, name='hello_world'),
]

Arquivo settings.py:

...

INSTALLED_APPS = [
    ...
    'myapp',
]

...

Arquivo requirements.txt:

Django==3.2.8

Código do arquivo Dockerfile:

# Use a imagem oficial do Python como base
FROM python:3.9

# Define o diretório de trabalho dentro do contêiner
WORKDIR /app

# Copia os arquivos de requisitos para o diretório de trabalho
COPY requirements.txt .

# Instala as dependências usando o pip
RUN pip install --no-cache-dir -r requirements.txt

# Copia todos os arquivos do diretório atual para o diretório de trabalho
COPY . .

# Expõe a porta 8000 para acesso externo
EXPOSE 8000

# Comando para iniciar a aplicação quando o contêiner for executado
CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

Para executar essa aplicação com Docker, siga estas etapas:

  • Execute o seguinte comando para construir a imagem Docker:
docker build -t minha-aplicacao-django .
  • Após a construção, execute o container:
docker run -p 8000:8000 minha-aplicacao-django
  • Abra o navegador no endereço http://localhost:8000

Docker com Node.Js usando o Express

Aplicação “Olá Mundo”, dessa vez em Javascript usando o Express. Nesse exemplo mostramos a estrutura da app e seu Dockerfile:

Exemplo de aplicação Javascript (NodeJS)

Código do arquivo package.json

{
  "name": "minha-aplicacao-node",
  "version": "1.0.0",
  "scripts": {
    "start": "node index.js"
  },
  "dependencies": {
    "express": "^4.17.1"
  }
}

Código do arquivo index.js

const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
  res.send('Olá Mundo');
});

app.listen(port, () => {
  console.log(`Aplicação está rodando em http://localhost:${port}`);
});

Código do arquivo Dockerfile:

# Use a imagem oficial do Node.js como base
FROM node:14-alpine

# Define o diretório de trabalho dentro do contêiner
WORKDIR /app

# Copia os arquivos necessários para o diretório de trabalho
COPY package.json .
COPY package-lock.json .

# Instala as dependências
RUN npm install

# Copia todos os arquivos do diretório atual para o diretório de trabalho
COPY . .

# Expõe a porta 3000 para acesso externo
EXPOSE 3000

# Comando para iniciar a aplicação quando o contêiner for executado
CMD ["npm", "start"]

Para executar essa aplicação com Docker, siga estas etapas:

  • Execute o seguinte comando para construir a imagem Docker:
docker build -t minha-aplicacao-node .
  • Após a construção, execute o container:
docker run -p 3000:3000 minha-aplicacao-node
  • Abra o navegador no endereço http://localhost:3000

Docker com  Go

API também no modelo “Olá Mundo”, usando Go com Fiber. Nesse exemplo mostramos a estrutura da app e seu Dockerfile:

Exemplo de aplicação Go

Código do arquivo main.jo

package main

import (
  "github.com/gofiber/fiber/v2"
)

func main() {
  // Cria uma instância do Fiber
  app := fiber.New()

  // Define a rota principal
  app.Get("/", func(c *fiber.Ctx) error {
    // Retorna um JSON com a mensagem "Olá Mundo"
    return c.JSON(fiber.Map{"mensagem": "Olá Mundo"})
  })

  // Inicia o servidor na porta 3000
  app.Listen(":3000")
}

Código do arquivo Dockerfile:

# Use a imagem oficial do Golang como base
FROM golang:1.18-alpine

# Define o diretório de trabalho dentro do contêiner
WORKDIR /app

# Copia todos os arquivos do diretório atual para o diretório de trabalho
COPY . .

# Constrói o executável da aplicação
RUN go build -o minha-aplicacao-go .

# Expõe a porta 3000 para acesso externo
EXPOSE 3000

# Comando para iniciar a aplicação quando o contêiner for executado
CMD ["./minha-aplicacao-go"]

Para executar essa aplicação com Docker, siga estas etapas:

  • Execute o seguinte comando para construir a imagem Docker:
docker build -t minha-aplicacao-go .
  • Após a construção, execute o container:
docker run -p 3000:3000 minha-aplicacao-go
  • Chame o endereço http://localhost:3000

Docker com  React

Pequena app também no modelo “Olá Mundo”, usando React. Nesse exemplo mostramos a estrutura da app e seu Dockerfile:

Exemplo de aplicação React

Código do arquivo <strong><code>src/App.js

import React from 'react';

function App() {
  return (
    <div>
      <h1>Olá Mundo</h1>
    </div>
  );
}

export default App;

Código do arquivo Dockerfile:

# Usando uma imagem oficial do Node.js como base
FROM node:14-alpine

# Definindo o diretório de trabalho dentro do contêiner
WORKDIR /app

# Copiando os arquivos de package.json e package-lock.json para o diretório de trabalho
COPY package*.json ./
RUN npm install --silent
RUN npm install react-scripts -g --silent

# Copiando todos os arquivos do diretório atual para o diretório de trabalho
COPY . .

# Expondo a porta 3000, que é a porta padrão usada pelo servidor de desenvolvimento do React
EXPOSE 3000

# Comando para iniciar a aplicação quando o contêiner for executado
CMD ["npm", "start"]

Para executar essa aplicação com Docker, siga estas etapas:

  • Execute o seguinte comando para construir a imagem Docker:
docker build -t minha-aplicacao-react .
  • Após a construção, execute o container:
docker run -p 3000:3000 minha-aplicacao-react
  • Abra o navegador no endereço http://localhost:3000

Docker com  Ruby on Rails

App Ruby on Rails com seu respectivo Dockerfile:

Exemplo de aplicação Ruby on Rails

Código do arquivo config/routes.rb:

Rails.application.routes.draw do
  root 'welcome#index'
end

Código do arquivo app/controllers/welcome_controller.rb

class WelcomeController < ApplicationController
  def index
    render plain: 'Olá Mundo'
  end
end

Código do arquivo Dockerfile:

# Use a imagem oficial do Ruby como base
FROM ruby:3.2.2

# Define o diretório de trabalho dentro do contêiner
WORKDIR /app

# Instala as dependências do Rails
RUN gem install rails

# Copia os arquivos necessários para o diretório de trabalho
COPY . .

# Instala as dependências do projeto
RUN bundle install

# Comando para criar o banco de dados e iniciar a aplicação quando o contêiner for executado
CMD ["bin/rails", "db:create", "db:migrate", "bin/rails", "server", "-b", "0.0.0.0"]

Para executar essa aplicação com Docker, siga estas etapas:

  • Execute o seguinte comando para construir a imagem Docker:
docker build -t minha-aplicacao-rails .
  • Após a construção, execute o container:
docker run -p 3000:3000 minha-aplicacao-rails
  • Abra o navegador no endereço http://localhost:3000

Docker com  WordPress

App Wordpres com seu respectivo Dockerfile e Docker-Compose (para o banco de dados):

Exemplo de aplicação WordPress

Código do arquivo Dockerfile:

# Use a imagem oficial do WordPress como base
FROM wordpress:latest

# Define o diretório de trabalho dentro do contêiner
WORKDIR /var/www/html

# Copia todos os arquivos do diretório atual para o diretório de trabalho
COPY . .

# Expõe a porta 80 para acesso externo
EXPOSE 80

Código do arquivo Docker-Compose:

version: '3'

services:
  wordpress:
    build: .
    ports:
      - "8080:80"
    environment:
      WORDPRESS_DB_HOST: db
      WORDPRESS_DB_USER: exampleuser
      WORDPRESS_DB_PASSWORD: examplepass
      WORDPRESS_DB_NAME: exampledb
    volumes:
      - ./wp-content:/var/www/html/wp-content

  db:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: examplepass
      MYSQL_DATABASE: exampledb
      MYSQL_USER: exampleuser
      MYSQL_PASSWORD: examplepass
      MYSQL_RANDOM_ROOT_PASSWORD: '1'

Para executar essa aplicação com Docker, siga estas etapas:

  • Execute o seguinte comando para levantar o ambiente:
docker-compose up -d
  • Abra o navegador no endereço http://localhost:8080

Como rodar seu banco de dados no Docker

Ao utilizar bancos de dados via Docker para apoiar o processo de desenvolvimento de uma aplicação no ambiente local, certas práticas são importantes.

Em primeiro lugar, é importante configurar volumes Docker para a persistência local de dados do banco, evitando a perda de informações entre reinicializações ou atualizações de containers, algo especialmente relevante no processo de desenvolvimento.

Outra dica importante é usar imagens oficiais do Docker Hub para o seu banco, mantendo sua imagem dentro dos padrões de desempenho e segurança criados pelo fornecedor do banco dados.

Mesmo em ambientes de desenvolvimento, manter sua base atualizada é importante, assim como garantir a segurança da imagem base do sistema operacional utilizada.

Docker com  Postgres

Aqui está um exemplo básico de um Dockerfile para rodar um banco de dados PostgreSQL. Este Dockerfile utiliza a imagem oficial do PostgreSQL disponível no Docker Hub.

Exemplo de Banco Postgres
# Use a imagem oficial do PostgreSQL como imagem base
FROM postgres:latest

# Defina variáveis de ambiente para configurar o PostgreSQL
ENV POSTGRES_DB=mydatabase \
    POSTGRES_USER=myuser \
    POSTGRES_PASSWORD=mypassword

# Exponha a porta padrão do PostgreSQL
EXPOSE 5432

# Comando padrão para iniciar o PostgreSQL
CMD ["postgres"]

Este Dockerfile faz o seguinte:

  1. Usa a imagem oficial mais recente do PostgreSQL como base.
  2. Define variáveis de ambiente para configurar o PostgreSQL, especificando o nome do banco de dados, usuário e senha.
  3. Copia scripts SQL de inicialização (se houver) para o diretório de inicialização do PostgreSQL. Scripts nesse diretório serão executados automaticamente durante a inicialização do banco de dados.
  4. Expõe a porta padrão do PostgreSQL (5432).
  5. Define o comando padrão para iniciar o PostgreSQL quando o container for executado.

Para executar o banco com Docker, siga estas etapas:

  • Execute o seguinte comando para construir a imagem Docker:
docker build -t postgress .
  • Após a construção, execute o container:
docker run -p 5432:5432 postgress
  • Conecte no banco de dados com as credenciais especificadas no Dockerfile

Docker com  Mysql

Aqui está um exemplo básico de um Dockerfile para rodar um banco de dados MySQL. Este Dockerfile utiliza a imagem oficial do MySQL disponível no Docker Hub

Exemplo de Banco Mysql
# Use a imagem oficial do MySQL como imagem base
FROM mysql:latest

# Defina variáveis de ambiente para configurar o MySQL
ENV MYSQL_DATABASE=mydatabase \
    MYSQL_USER=myuser \
    MYSQL_PASSWORD=mypassword \
    MYSQL_ROOT_PASSWORD=myrootpassword

# Exponha a porta padrão do MySQL
EXPOSE 3306

# Comando padrão para iniciar o MySQL
CMD ["mysqld"]

Este Dockerfile realiza as seguintes ações:

  1. Usa a imagem oficial mais recente do MySQL como base.
  2. Define variáveis de ambiente para configurar o MySQL, especificando o nome do banco de dados, usuário, senha do usuário e senha do usuário root.
  3. Copia scripts SQL de inicialização (se houver) para o diretório de inicialização do MySQL. Scripts nesse diretório serão executados automaticamente durante a inicialização do banco de dados.
  4. Expõe a porta padrão do MySQL (3306).
  5. Define o comando padrão para iniciar o MySQL quando o container for executado.

Para executar o banco com Docker, siga estas etapas:

  • Execute o seguinte comando para construir a imagem Docker:
docker build -t mysql .
  • Após a construção, execute o container:
docker run -p 3306:3306 mysql
  • Conecte no banco de dados com as credenciais especificadas no Dockerfile

Docker com  MongoDB

Aqui está um exemplo básico de um Dockerfile para rodar um banco de dados MongoDB. Este Dockerfile utiliza a imagem oficial do MongoDB disponível no Docker Hub

Exemplo de Banco MongoDB
# Use a imagem oficial do MongoDB como imagem base
FROM mongo:latest

# Exponha a porta padrão do MongoDB
EXPOSE 27017

# Comando padrão para iniciar o MongoDB
CMD ["mongod"]

Este Dockerfile realiza as seguintes ações:

  1. Usa a imagem oficial mais recente do MongoDB como base.
  2. Expõe a porta padrão do MongoDB (27017).
  3. Define o comando padrão para iniciar o MongoDB quando o container for executado.

Para executar o banco com Docker, siga estas etapas:

  • Execute o seguinte comando para construir a imagem Docker:
docker build -t mongodb .
  • Após a construção, execute o container:
docker run -p 27017:27017 mongodb
  • Conecte no banco de dados com as credenciais especificadas no Dockerfile

Este exemplo é mais simples em comparação com os bancos de dados. Para configurações avançadas ou autenticação, consulte a documentação oficial do MongoDB e ajuste conforme necessário.

Como rodar Containers Docker em Produção

A adoção de containers em ambientes de produção tem experimentado um crescimento significativo nos últimos anos, impulsionada pela necessidade de agilidade, escalabilidade e consistência na implantação de aplicativos.

Empresas de diversos setores têm reconhecido os benefícios dos containers, que proporcionam isolamento, portabilidade e eficiência na execução de aplicações em diferentes ambientes. Essa tendência é particularmente evidente em arquiteturas de microsserviços, onde a modularidade e a flexibilidade dos containers facilitam o desenvolvimento, implantação e manutenção de serviços independentes.

Os principais provedores de computação em nuvem, como AWS, Azure e Google Cloud, têm respondido a essa demanda crescente ao oferecer serviços especializados para a orquestração e gerenciamento de containers.

Vamos listar abaixo algumas soluções que esses provedores de cloud oferece que permite a execução de containers Docker em produção. Vamos lá!

Rodando containers Docker na AWS

Não são poucos os serviços que a AWS oferece para rodar containers Docker, proporcionando flexibilidade e escalabilidade. Abaixo estão alguns dos principais serviços AWS para essa finalidade:

Amazon Elastic Container Service (ECS)

O ECS é um serviço de orquestração de containers que simplifica o gerenciamento, escalabilidade e implantação de containers Docker na AWS. Ele suporta tarefas e serviços, permitindo a execução de containers em clusters gerenciados.

Amazon Elastic Kubernetes Service (EKS)

O EKS é um serviço totalmente gerenciado que facilita a execução do Kubernetes na AWS. Ele oferece a capacidade de orquestrar containers Docker usando o Kubernetes, proporcionando uma abordagem mais flexível e amplamente adotada.

Amazon Fargate

O Fargate é um mecanismo de computação serverless para containers, permitindo que você execute containers sem gerenciar a infraestrutura subjacente. Ele pode ser utilizado tanto com o ECS quanto com o EKS, simplificando a execução de containers sem a necessidade de provisionar ou gerenciar servidores.

Amazon Lightsail

O Amazon Lightsail é um serviço simples que permite executar containers Docker em uma infraestrutura gerenciada. Ele oferece uma abordagem fácil e acessível para implantar e gerenciar containers.

AWS Batch

O AWS Batch é um serviço focado em cargas de trabalho de processamento em lote. Ele permite a execução de trabalhos usando containers Docker, gerenciando automaticamente a escalabilidade e a distribuição de tarefas em clusters de instâncias EC2

AWS App Runner

O AWS App Runner é um serviço que facilita a implantação, execução e escalabilidade de aplicações contêinerizadas sem a necessidade de gerenciar a infraestrutura subjacente. Ele suporta a execução de containers Docker em uma plataforma totalmente gerenciada.

Ufa! São muitas as opções para executar containers Docker na AWS, atendendo a diferentes necessidades e preferências de desenvolvimento e operações.

Rodando containers Docker na GCP

A Google Cloud Platform (GCP) também não fica de fora da festa, oferecendo diversos serviços que podem ser utilizados para rodar containers Docker.

Vamos ver alguns dos principais serviços da GCP para essa finalidade:

Google Kubernetes Engine (GKE)

O GKE é um serviço gerenciado do Kubernetes que simplifica a orquestração de containers Docker. Ele oferece um ambiente de execução Kubernetes totalmente gerenciado, permitindo a implantação, dimensionamento e gerenciamento eficiente de aplicativos em containers.

Cloud Run

O Cloud Run é um serviço completamente gerenciado para execução de containers sem servidor. Ele permite que você execute containers Docker em um ambiente sem estado, fornecendo escalabilidade automática com base na demanda.

Google Compute Engine (GCE)

O GCE oferece máquinas virtuais flexíveis que podem ser usadas para executar containers Docker. Embora não seja um serviço específico de containers, ele fornece uma infraestrutura robusta para execução de containers em VMs personalizadas.

Google Cloud Build

O Cloud Build é um serviço de CI/CD que permite automatizar a construção e implantação de containers Docker. Ele pode ser integrado a repositórios Git, como o Cloud Source Repositories.

Google Artifact Registry

O Artifact Registry é um serviço para armazenamento, gerenciamento e implantação de imagens de containers Docker. Ele fornece um repositório privado e seguro para suas imagens Docker. Pense nesse serviço como uma alternativa ao Docker Hub.

Rodando containers Docker na Azure

A Microsoft Azure também traz diversas soluções para rodar containers Docker. Abaixo listamos algumas delas:

Azure Kubernetes Service (AKS)

O AKS é um serviço gerenciado do Kubernetes que simplifica a orquestração de containers Docker. Ele oferece um ambiente de execução Kubernetes totalmente gerenciado, permitindo a implantação, dimensionamento e gerenciamento eficiente de aplicativos em containers.

Azure Container Instances (ACI)

O ACI é um serviço serverless que permite executar containers sem a necessidade de provisionar ou gerenciar máquinas virtuais. Ele fornece uma experiência leve e rápida para cargas de trabalho de containers.

Azure Container Registry (ACR)

ACR é um serviço para armazenamento, gerenciamento e implantação de imagens de containers Docker. Ele oferece um repositório privado e seguro para suas imagens Docker, integrando-se facilmente a outros serviços Azure.

Azure Service Fabric

O Azure Service Fabric é uma plataforma de computação distribuída que suporta a execução de microsserviços em containers Docker. Ele oferece escalabilidade e alta disponibilidade para aplicativos distribuídos.

Azure DevOps Services

O Azure DevOps Services inclui recursos para CI/CD de aplicativos em containers. Ele oferece integração com repositórios Git, pipelines de construção e implantação automatizada.

Azure Functions com Suporte a Containers

O Azure Functions oferece suporte a containers, permitindo que você execute funções serverless em containers Docker. Isso proporciona uma abordagem serverless para cargas de trabalho específicas.

Links Úteis

Exit mobile version