Este tutorial de Dockerfile tem como objetivo fornecer uma introdução abrangente à criação e utilização de Dockerfiles. Seja você novo no Docker ou procurando aprimorar seus conhecimentos existentes, este guia irá guiá-lo pelos fundamentos dos Dockerfiles, desde a compreensão de imagens e contêineres Docker até a construção e otimização de suas próprias imagens Docker personalizadas.
O Docker é uma plataforma de código aberto que permite aos desenvolvedores construir, implantar e executar aplicações num ambiente consistente e isolado, chamado contêiner. Os contêineres empacotam uma aplicação e suas dependências numa única unidade portátil, garantindo que a aplicação execute da mesma forma, independentemente da infraestrutura subjacente.
Um Dockerfile é um script baseado em texto que contém um conjunto de instruções para construir uma imagem Docker. Ele especifica a imagem base, as etapas a serem executadas e as configurações de configuração para o contêiner. Ao usar um Dockerfile, você pode automatizar o processo de criação e gerenciamento de imagens Docker, tornando mais fácil construir, distribuir e implantar suas aplicações.
Para começar com Docker e Dockerfiles, você precisará ter o Docker instalado em seu sistema. Você pode baixar e instalar o Docker no site oficial do Docker (https://www.docker.com/get-started). Depois de instalar o Docker, você pode começar a criar seus próprios Dockerfiles e construir imagens Docker.
## Instalar o Docker no Ubuntu 22.04
sudo apt-get update
sudo apt-get install -y docker.ioNa próxima seção, aprofundaremos na estrutura e sintaxe dos Dockerfiles e aprenderemos a construir imagens Docker personalizadas.
Uma imagem Docker é um modelo de leitura-somente que contém um conjunto de instruções para criar um contêiner Docker. Inclui o código da aplicação, o tempo de execução, as ferramentas do sistema, as bibliotecas e quaisquer outros ficheiros necessários para executar a aplicação. As imagens Docker são construídas usando um Dockerfile e podem ser partilhadas e distribuídas através de registos Docker, como o Docker Hub.
Um contêiner Docker é uma instância executável de uma imagem Docker. Os contêineres são pacotes leves, autónomos e executáveis que incluem tudo o que é necessário para executar uma aplicação, incluindo o código, o tempo de execução, as ferramentas do sistema e as bibliotecas do sistema. Os contêineres são isolados uns dos outros e do sistema operativo hospedeiro, garantindo uma implantação de aplicações consistente e fiável.
## Executar um contêiner Ubuntu simples
docker run -it ubuntu:22.04 bashAs imagens Docker são compostas por múltiplas camadas, cada uma representando um conjunto de alterações feitas à imagem base. Quando constrói uma nova imagem, o Docker utiliza o cache de imagens para reutilizar estas camadas, tornando o processo de construção mais eficiente. Este mecanismo de cache ajuda a acelerar o processo de construção e a reduzir o tamanho da imagem final.
Pode empurrar as suas imagens Docker personalizadas para um registo, como o Docker Hub, para as partilhar com outros ou implantá-las em diferentes ambientes. Reciprocamente, pode puxar imagens de um registo para as utilizar nos seus próprios projetos.
## Empurrar uma imagem Docker para o Docker Hub
docker push labex/my-app:latest
## Puxar uma imagem Docker do Docker Hub
docker pull labex/my-app:latestNa próxima seção, exploraremos a sintaxe e estrutura essenciais dos Dockerfiles, que pode utilizar para construir as suas próprias imagens Docker personalizadas.
Um Dockerfile é um script baseado em texto que contém um conjunto de instruções para construir uma imagem Docker. A sintaxe básica de um Dockerfile é a seguinte:
## Comentário
INSTRUÇÃO argumentoAs instruções mais comuns num Dockerfile incluem:
| Instrução | Descrição |
|---|---|
FROM |
Especifica a imagem base a utilizar para a construção |
RUN |
Executa um comando no contêiner durante a construção |
COPY |
Copia ficheiros ou diretórios do host para o contêiner |
ADD |
Similar a COPY, mas também pode descarregar ficheiros remotos e extrair arquivos |
CMD |
Especifica o comando padrão a executar quando o contêiner é iniciado |
EXPOSE |
Informa o Docker que o contêiner escuta nas portas de rede especificadas |
ENV |
Define uma variável de ambiente |
WORKDIR |
Define o diretório de trabalho para quaisquer instruções RUN, CMD, ENTRYPOINT, COPY e ADD que se seguem |
Um Dockerfile típico segue esta estrutura:
ubuntu:22.04, usando a instrução FROM.RUN para atualizar o gestor de pacotes e instalar as dependências necessárias.COPY para copiar o código da sua aplicação para o contêiner.ENV para definir quaisquer variáveis de ambiente necessárias.EXPOSE para expor as portas nas quais a sua aplicação irá escutar.CMD ou ENTRYPOINT para especificar o comando padrão a executar quando o contêiner é iniciado.Aqui está um exemplo de Dockerfile para uma aplicação web Python simples:
FROM python:3.9-slim
## Atualizar o gestor de pacotes e instalar dependências
RUN apt-get update && apt-get install -y \
build-essential \
libpq-dev \
&& rm -rf /var/lib/apt/lists/*
## Copiar o código da aplicação
COPY . /app
WORKDIR /app
## Instalar dependências Python
RUN pip install --no-cache-dir -r requirements.txt
## Expor a porta em que a aplicação irá rodar
EXPOSE 8000
## Definir o ponto de entrada
CMD ["python", "app.py"]Na próxima seção, exploraremos como construir imagens Docker personalizadas usando Dockerfiles.
Para construir uma imagem Docker personalizada, precisará criar um Dockerfile. Comece criando um novo ficheiro chamado Dockerfile no diretório do seu projeto. Este ficheiro conterá as instruções para construir a sua imagem Docker.
Depois de ter o seu Dockerfile pronto, pode construir a imagem Docker usando o comando docker build:
docker build -t labex/my-app:latest .Este comando lerá o Dockerfile, executará as instruções e criará uma nova imagem Docker com o nome labex/my-app:latest. O . no final do comando especifica o contexto de construção, que é o diretório onde o Dockerfile está localizado.
Quando executa o comando docker build, o Docker executará as instruções do Dockerfile passo a passo. Cada instrução criará uma nova camada na imagem, e o Docker utilizará o cache da imagem para otimizar o processo de construção.
Após a construção da imagem, pode etiquetá-la com uma versão específica ou rótulo e, em seguida, publicá-la num registo Docker, como o Docker Hub, para que outros a possam utilizar.
## Etiquetar a imagem
docker tag labex/my-app:latest labex/my-app:v1.0
## Publicar a imagem no Docker Hub
docker push labex/my-app:v1.0Uma vez que a imagem esteja disponível num registo, pode puxá-la e executar um contêiner baseado na imagem:
## Puxar a imagem do Docker Hub
docker pull labex/my-app:v1.0
## Executar um contêiner a partir da imagem
docker run -p 8000:8000 labex/my-app:v1.0Na próxima seção, discutiremos como otimizar as camadas do Dockerfile para uma melhor eficiência.
Como mencionado anteriormente, as imagens Docker são compostas por múltiplas camadas, onde cada camada representa um conjunto de alterações feitas à imagem base. Estas camadas são armazenadas em cache pelo Docker, o que ajuda a acelerar o processo de construção.
Para otimizar as camadas Dockerfile para melhor eficiência, siga estas práticas recomendadas:
Agrupar Instruções Relacionadas: Agrupe instruções relacionadas para tirar partido do cache da imagem. Por exemplo, instale todas as dependências numa única instrução RUN em vez de usar múltiplas instruções RUN.
Minimizar o Número de Camadas: Cada instrução no Dockerfile cria uma nova camada, por isso tente minimizar o número de camadas combinando instruções sempre que possível.
Utilizar Construções Multi-Fase: As construções multi-fase permitem usar múltiplas instruções FROM num único Dockerfile, o que pode ajudar a criar imagens menores e mais eficientes.
Aproveitar o Cache da Imagem: Organize as instruções do seu Dockerfile de forma a tirar partido do cache da imagem. Por exemplo, coloque instruções menos suscetíveis a mudanças (por exemplo, instalação de dependências de sistema) mais cedo no Dockerfile.
Aqui está um exemplo de um Dockerfile otimizado:
FROM python:3.9-slim AS base
## Instalar dependências de sistema
RUN apt-get update && apt-get install -y \
build-essential \
libpq-dev \
&& rm -rf /var/lib/apt/lists/*
## Criar um utilizador não-root
RUN useradd -m -s /bin/bash appuser
USER appuser
WORKDIR /app
## Instalar dependências Python
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
## Copiar o código da aplicação
COPY . .
## Expor a porta e definir o ponto de entrada
EXPOSE 8000
CMD ["python", "app.py"]Neste exemplo, agrupámos instruções relacionadas, minimizamos o número de camadas e aproveitámos o cache da imagem para criar um Dockerfile mais eficiente.
Pode definir variáveis de ambiente num Dockerfile usando a instrução ENV. Isto permite definir variáveis de ambiente que estarão disponíveis no contêiner durante a execução.
ENV APP_ENV=production
ENV DB_HOST=postgres.example.com
ENV DB_PASSWORD=secretDepois de definir uma variável de ambiente no Dockerfile, pode referenciá-la noutras instruções usando o prefixo $.
ENV APP_ENV=production
COPY config.$APP_ENV.yml /app/config.ymlTambém pode sobrescrever variáveis de ambiente em tempo de execução quando executa um contêiner usando a flag -e ou --env.
docker run -e DB_PASSWORD=newpassword labex/my-app:latestAqui estão algumas boas práticas para gerir variáveis de ambiente em Dockerfiles:
Seguindo estas boas práticas, pode gerir eficazmente as variáveis de ambiente nos seus Dockerfiles e garantir que os seus contêineres estão configurados corretamente.
Para tornar o seu aplicativo acessível de fora do contêiner, é necessário expor as portas nas quais o aplicativo está a escutar. Pode usar a instrução EXPOSE no seu Dockerfile para especificar as portas a expor.
EXPOSE 8000
EXPOSE 5432Quando executa um contêiner baseado nesta imagem, pode mapear as portas expostas para o sistema hospedeiro usando a flag -p ou --publish.
docker run -p 8000:8000 -p 5432:5432 labex/my-app:latestPode usar as instruções CMD e ENTRYPOINT no seu Dockerfile para especificar o comando padrão a ser executado quando um contêiner é iniciado.
A instrução CMD define o comando padrão e quaisquer argumentos que devem ser-lhe passados. Se a instrução CMD for usada, o comando docker run pode sobrescrever o comando padrão.
CMD ["python", "app.py"]A instrução ENTRYPOINT define o aplicativo padrão que será executado quando o contêiner é iniciado. O comando ENTRYPOINT não pode ser sobrescrito pelo comando docker run, mas pode passar argumentos para ele.
ENTRYPOINT ["python"]
CMD ["app.py"]Neste exemplo, quando executa o contêiner, o comando python app.py será executado.
docker run labex/my-app:latestTambém pode usar a instrução RUN para executar comandos durante o processo de construção, o que pode ser útil para tarefas como instalar dependências ou configurar o ambiente do aplicativo.
RUN apt-get update && apt-get install -y \
build-essential \
libpq-dev \
&& rm -rf /var/lib/apt/lists/*Compreendendo como expor portas e executar comandos em contêineres, pode garantir que os seus aplicativos são acessíveis e configurados corretamente no ambiente Docker.
A instrução COPY em um Dockerfile é usada para copiar arquivos ou diretórios da máquina hospedeira para a imagem Docker. A sintaxe da instrução COPY é:
COPY <src> <dest>Aqui, <src> é o caminho para o arquivo ou diretório na máquina hospedeira, e <dest> é o caminho para onde o arquivo ou diretório será copiado dentro do contêiner Docker.
COPY requirements.txt /app/
COPY . /app/No exemplo acima, o arquivo requirements.txt e todo o diretório atual (.) são copiados para o diretório /app/ dentro do contêiner Docker.
A instrução ADD é semelhante à instrução COPY, mas possui recursos adicionais. A instrução ADD pode copiar arquivos de um URL remoto e também pode extrair arquivos compactados (por exemplo, .tar.gz, .zip) diretamente na imagem Docker.
ADD https://example.com/file.tar.gz /app/
ADD local_file.tar.gz /app/No exemplo acima, o arquivo file.tar.gz é baixado de um URL remoto e extraído no diretório /app/, e o arquivo local_file.tar.gz é copiado e extraído no diretório /app/.
Aqui estão algumas boas práticas a considerar ao copiar arquivos e diretórios para imagens Docker:
COPY em vez de ADD, pois COPY é mais direta e menos propensa a comportamentos inesperados..dockerignore no diretório do seu projeto para excluir arquivos e diretórios que não deseja incluir no contexto de construção do Docker.COPY de forma a aproveitar o cache de construção do Docker. Coloque instruções que copiam arquivos menos propensos a mudanças mais cedo no Dockerfile.Seguindo essas boas práticas, você pode garantir que suas imagens Docker sejam eficientes, manuteníveis e contenham apenas os arquivos e dependências necessários.
Atribua nomes descritivos aos seus Dockerfiles e imagens Docker, que comuniquem claramente o seu propósito. Além disso, utilize comentários para explicar o propósito de cada seção ou instrução no seu Dockerfile.
## Utilize uma imagem base com as atualizações de segurança mais recentes
FROM ubuntu:22.04
## Instale as dependências necessárias
RUN apt-get update && apt-get install -y \
build-essential \
libpq-dev \
&& rm -rf /var/lib/apt/lists/*
## Copie o código do aplicativo
COPY . /app
WORKDIR /appConstruções multi-fase permitem utilizar múltiplas instruções FROM num único Dockerfile, o que pode ajudar a criar imagens menores e mais eficientes. Isto é particularmente útil quando precisa de construir o seu aplicativo utilizando uma cadeia de ferramentas específica, mas não pretende incluir toda a cadeia de ferramentas na imagem final.
## Fase de construção
FROM python:3.9-slim AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
## Fase final
FROM python:3.9-slim
COPY --from=builder /usr/local/lib/python3.9/site-packages /usr/local/lib/python3.9/site-packages
COPY --from=builder /app /app
WORKDIR /app
CMD ["python", "app.py"]Como discutido anteriormente, utilize variáveis de ambiente para armazenar definições de configuração e siga as melhores práticas para as gerir nos seus Dockerfiles.
Organize as instruções do seu Dockerfile de forma a tirar partido do cache de construção do Docker. Agrupe instruções relacionadas e coloque instruções menos suscetíveis a alterações mais cedo no Dockerfile.
Utilize um arquivo .dockerignore para excluir arquivos e diretórios que não são necessários na imagem Docker final, reduzindo o contexto de construção e melhorando os tempos de construção.
Certifique-se de que os seus Dockerfiles estão bem documentados, incluindo informações sobre o propósito da imagem, as variáveis de ambiente utilizadas e quaisquer instruções especiais para a construção ou execução do contêiner.
Seguindo estas melhores práticas, pode criar Dockerfiles fáceis de compreender, manter e estender, tornando os seus aplicativos baseados em Docker mais robustos e escaláveis.
Certifique-se de que a sintaxe do seu Dockerfile está correta. Erros de sintaxe comuns incluem instruções ausentes ou incorretas, aspas ausentes e indentação incorreta.
## Exemplo de um erro de sintaxe
FROM ubuntu:22.04
RUN apt-get update
apt-get install -y build-essentialSe a construção do Docker falhar, verifique os logs de construção para mensagens de erro que podem ajudá-lo a identificar o problema. Problemas comuns de falha na construção incluem:
## Exemplo de uma falha na construção devido a dependências ausentes
RUN apt-get update && apt-get install -y \
build-essential \
libpq-dev \
## Este pacote está ausente
libssl-dev \
&& rm -rf /var/lib/apt/lists/*Se o seu contêiner Docker não estiver a comportar-se como esperado, verifique os logs do contêiner para quaisquer mensagens de erro ou comportamento inesperado. Problemas comuns de execução incluem:
## Exemplo de um problema de execução devido a um mapeamento de porta incorreto
EXPOSE 8000
## Ao executar o contêiner, a porta não está mapeada corretamente
docker run -p 8080:8000 labex/my-app:latestPode utilizar as seguintes técnicas para depurar os seus Dockerfiles:
docker build com a flag --no-cache para forçar uma reconstrução completa e ignorar o cache de imagem.docker run com a flag --rm para remover automaticamente o contêiner após a sua saída, facilitando a inspeção do estado do contêiner.docker logs para visualizar os logs de um contêiner em execução.docker exec para entrar num contêiner em execução e inspecionar o seu sistema de arquivos ou executar comandos adicionais.Compreendendo os problemas comuns em Dockerfiles e utilizando as técnicas de depuração apropriadas, pode identificar e resolver rapidamente problemas nos seus aplicativos baseados em Docker.
Ao final deste tutorial sobre Dockerfiles, você terá um conhecimento sólido da sintaxe e estrutura de Dockerfiles, permitindo criar e gerenciar suas próprias imagens Docker de forma eficaz. Você aprenderá as melhores práticas para escrever Dockerfiles manuteníveis, bem como técnicas para solucionar problemas comuns. Com esse conhecimento, estará bem equipado para otimizar seus fluxos de trabalho de desenvolvimento e implantação usando o poder do Docker.
