Elementos e exemplos de escrita do Dockerfile

Escrever um Dockerfile é um arquivo chave usado para definir o processo de construção de imagens do Docker. Aqui estão os elementos a serem considerados ao escrever um Dockerfile:

1. Imagem base: Escolha uma imagem base adequada como ponto de partida. Você pode escolher a imagem base oficial ou usar outras imagens base personalizadas ou de terceiros.

2. Operações do sistema de arquivos: copie arquivos ou diretórios locais para o local especificado na imagem por meio de instruções como COPY e ADD. Esses arquivos e diretórios farão parte da construção.

3. Comando de construção: execute comandos dentro do contêiner por meio do comando RUN. Você pode executar qualquer comando que possa ser executado em um contêiner, como instalar pacotes, configurar o ambiente, compilar código, etc.

4. Variáveis ​​de ambiente: Defina variáveis ​​de ambiente por meio da instrução ENV. Essas variáveis ​​de ambiente podem ser usadas para configurar parâmetros ou passar informações quando o aplicativo estiver em execução.

5. Comando de inicialização do contêiner: Use a instrução CMD ou ENTRYPOINT para definir o comando a ser executado quando o contêiner for iniciado. A instrução CMD fornece valores padrão, mas pode ser substituída pelos parâmetros da linha de comando do docker run; enquanto a instrução ENTRYPOINT especifica o ponto de entrada do contêiner, e os parâmetros da linha de comando do docker run serão passados ​​como parâmetros para o comando do ponto de entrada.

6. Exposição da porta: Declare a porta que o contêiner irá escutar por meio da diretiva EXPOSE. Isso não mapeia automaticamente a porta do host, mas apenas fornece informações para o contêiner se comunicar com o mundo externo, que precisa ser usado em conjunto com os parâmetros ao executar o contêiner -p.

7. Diretório de trabalho: Defina o diretório de trabalho dentro do contêiner por meio da diretiva WORKDIR. Os comandos subsequentes serão executados neste diretório.

8. Contexto de construção da imagem: todos os arquivos e pastas no diretório onde o Dockerfile está localizado e seus subdiretórios serão passados ​​para o mecanismo Docker como o contexto de construção. Portanto, esteja ciente do tamanho e do conteúdo do seu contexto de construção ao escrever seu Dockerfile.

9. Comentários: Adicione comentários através de #símbolos para melhorar a legibilidade e explicar e ilustrar o processo de construção da imagem.

Estes são alguns elementos básicos a considerar ao escrever um Dockerfile.Dependendo das suas necessidades específicas,talvez também seja necessário utilizar outras instruções e técnicas para satisfazer as suas necessidades específicas de construção. Você pode consultar a documentação oficial do Docker para obter instruções mais detalhadas e instruções de uso.

Aqui estão 10 exemplos de Dockerfile comumente usados:

1. Crie uma imagem baseada em Ubuntu e instale o ambiente Python:

FROM ubuntu:latest
RUN apt-get update && apt-get install -y python3

2. Crie uma imagem baseada em Node.js e copie os arquivos locais no contêiner:

FROM node:latest
WORKDIR /app
COPY . .
RUN npm install

3. Crie uma imagem usando Nginx como servidor web e copie o arquivo HTML local para o contêiner:

FROM nginx:latest
COPY index.html /usr/share/nginx/html/

4. Extraia uma imagem Redis existente do Docker Hub:

FROM redis:latest

5. Crie uma imagem de construção de vários estágios para compilar aplicativos em linguagem Go e minimizar o tamanho da imagem de tempo de execução:

# 阶段一：编译
FROM golang:latest as builder
WORKDIR /app
COPY . .
RUN go build -o myapp

# 阶段二：运行
FROM alpine:latest
COPY --from=builder /app/myapp /usr/local/bin/myapp
CMD ["myapp"]

6. Crie uma imagem com variáveis ​​de ambiente e comandos de inicialização:

FROM debian:latest
ENV MY_ENV_VAR="Hello, World!"
RUN echo $MY_ENV_VAR
CMD ["echo", "Docker is awesome!"]

7. Crie uma imagem de ferramenta que limpe regularmente imagens e contêineres inúteis em contêineres:

FROM docker:latest
RUN apk update && apk add bash
COPY cleanup.sh /cleanup.sh
RUN chmod +x /cleanup.sh
CMD ["/bin/bash", "/cleanup.sh"]

8. Construa uma imagem para instalar um aplicativo Java usando OpenJDK:

FROM openjdk:latest
WORKDIR /app
COPY app.jar .
CMD ["java", "-jar", "app.jar"]

9. Crie uma imagem de aplicativo Python baseada em Alpine Linux e especifique parâmetros de tempo de execução:

FROM python:3.9-alpine
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "app.py"]

10. Crie uma imagem com um banco de dados MySQL e inicialize o banco de dados:

FROM mysql:latest
COPY init.sql /docker-entrypoint-initdb.d/init.sql

Aqui estão alguns exemplos comuns do Dockerfile que cobrem diferentes tipos de aplicativos e casos de uso. Esses exemplos podem ser modificados e ampliados com base em necessidades específicas.