Estou criando um Containerfilelocal onde recebo uma pasta de entrada do host que contém os arquivos que preciso dentro do meu contêiner.

A melhor maneira que conheço seria passando por um volume como:
-v /host/path:/opt/input.

Mas eu gostaria de abstrair o /opt/inputdo usuário do contêiner da mesma forma que é possível passar um nome de volume:
-v volume-name:/opt/input.

O VOLUME não funciona bem assim, mas o que estou tentando alcançar é:

VOLUME ["input-data": "/opt/input"]

Então o usuário pode fazer:
-v /host/path:input-data

E facilitando a evolução do arquivo do contêiner sem quebrar a compatibilidade, caso algum dia eu precise alterar esse caminho.

Existe alguma outra alternativa que eu ainda não consegui descobrir?

Pergunta em questão: se eu precisar copiar centenas de bibliotecas de dependências entre compilações de estágios no Docker, como faço isso sem atingir a profundidade máxima?

O que estou tentando fazer: criar uma imagem de contêiner tão pequena quanto possível contendo Python e ffmpeg para uso com o AWS Lambda.

O que eu sei que posso fazer:

FROM ubuntu:latest AS build

RUN apt-get update && apt-get clean && apt-get install -y ffmpeg

FROM python:3.12-slim-bookworm

COPY --from=build /usr/bin/ffmpeg /usr/bin/ffmpeg
COPY --from=build /usr/lib/aarch64-linux-gnu/* /usr/lib/aarch64-linux-gnu/

WORKDIR /app

CMD ["foo"]

Produz uma imagem de contêiner funcional, mas é enorme, mais de 1 GB.

Gostaria de copiar apenas o ffmpeg e suas dependências, mas esse é o problema. lddme diz que há mais de 200 dependências em /lib, e ter tantas COPYinstruções leva a exceder a profundidade máxima durante a compilação. Tentando evitar:

COPY --from=build /usr/lib/lib1 /usr/lib/lib1
COPY --from=build /usr/lib/lib2 /usr/lib/lib2
...
COPY --from=build /usr/lib/lib227 /usr/lib/lib227

Existe uma maneira de fazer um loop dentro do Dockerfile a partir de um arquivo txt externo ou algum outro mecanismo para copiar centenas de dependências sem exceder a profundidade máxima?

Tenho um aplicativo Rust Axum que lê a URL do banco de dados logo no início para criar uma conexão com o banco de dados:

async fn main() {
    let db_connection_str = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set.");
    println!("Connecting to database: {}", db_connection_str);


    let pool = PgPoolOptions::new()
       .max_connections(5)
       .acquire_timeout(Duration::from_secs(3))
       .connect(&db_connection_str)
       .await
       .expect("can't connect to database");

O problema é que não está obtendo a variável de ambiente. db_connection_strestá vazio, e recebo isso printlnno console "Conectando ao banco de dados: " sem o valor real.

este é o dockerfile

FROM rust:1.84 AS development

WORKDIR /backend

COPY . .

ARG DATABASE_URL
ENV DATABASE_URL=$DATABASE_URL

RUN cargo run

E aqui está o arquivo docker-compose

  backend:
    build: ./backend
    ports:
      - "5173:5173"
    environment:
      DATABASE_URL: $DATABASE_URL

Tenho um .envarquivo para variáveis ​​de ambiente.

Nota: Quando executo este comando

docker build -t backend --build-arg DATABASE_URL=<Database_url> .

funciona, obtém a variável de ambiente, mas quando executo docker-compose upnão, e o problema mencionado acima acontece.

Quero entender por que isso acontece. Quando uso proxy_pass sem expressões regulares, tudo funciona muito bem , o DNS é resolvido, e assim por diante.

    location /images/ {
        proxy_pass http://sfs-filer:8888;
        proxy_set_header Host $host;
    }

Mas assim que adiciono expressões regulares, ele começa a gerar um ERRO.

[erro] 29#29: *442 nenhum resolvedor definido para resolver sfs-filer, cliente: 172.18.0.1, servidor: , solicitação: "GET /9395123a-39bd-4951-acd9-e759fae2e7f4.webp HTTP/1.1", host: "localhost"

    location ~ ([a-zA-Z0-9-]+\.(jpg|jpeg|png|gif|webp|bmp|avif))$ {
        proxy_pass http://sfs-filer:8888/$1;
        proxy_set_header Host $host;
    }

Observe que em proxy_pass eu não altero o domínio de forma alguma , ele permanece 1 para 1 como no primeiro exemplo. Como isso é possível? Por que o resolver depende de expressões regulares?

Sim, eu posso adicionar resolver 127.0.0.11 valid=10s;e vai funcionar. Mas a essência disso é um mistério absoluto para mim.

No meu pipeline de construção, puxo este contêiner:

mcr.microsoft.com/dotnet/sdk:8.0.405

Quando executo dotnet format --versiondentro desse contêiner, recebo o seguinte número de versão:

8.3.546805+86f5186deeea364bd8541d51657e52a54b2a96b2

Por que eu obteria o formato .NET versão 8.3 quando estou solicitando especificamente a versão 8.0.405 do contêiner?

Localmente tenho o .Net SDK instalado na versão 8.0.405 e quando executo dotnet format --versionobtenho corretamente:

Welcome to .NET 8.0!
---------------------
SDK Version: 8.0.405

Eu simplesmente não entendo qual é a discrepância.

Isso está me causando um problema, pois o formatcomando se comporta de forma diferente no meu servidor de compilação do que quando executado localmente, mas as versões devem ser exatamente as mesmas.

Estou com dificuldades para compilar um repositório com o Docker. Ainda não fiz nenhuma alteração no código-fonte e estou apenas tentando compilar o master. Mas estou com dificuldades para compilá-lo de acordo com as instruções no repositório: NickelMenu

De acordo com as instruções, o código-fonte deve ser compilado com o docker com:

docker run --volume="$PWD:$PWD" --user="$(id --user):$(id --group)" --workdir="$PWD" --env=HOME --entrypoint=make --rm -it ghcr.io/pgaskin/nickeltc:1.0 all koboroot

Primeiro, estou recebendo um aviso (e erro) dizendo: AVISO: A plataforma da imagem solicitada (linux/amd64) não corresponde à plataforma do host detectada (linux/arm64/v8) e nenhuma plataforma específica foi solicitada exec /usr/bin/make: erro de formato exec

Então eu pesquisei e descobri que preciso especificar a plataforma se tiver uma arquitetura de plataforma diferente no host. Estou tentando executar isso em um raspi (linux/arm64/v8?), mas o host é linux/amd64 para image ghcr.io/pgaskin/nickeltc:1.0. Então eu tentei:

sudo DOCKER_DEFAULT_PLATFORM="linux/amd64" docker run --volume="$PWD:$PWD" --user="$(id --user):$(id --group)" --workdir="$PWD" --env=HOME --entrypoint=make --rm -it ghcr.io/pgaskin/nickeltc:1.0 all koboroot

O aviso foi removido, mas ainda recebo o erro: exec /usr/bin/make: erro de formato exec

Eu apreciaria se alguém pudesse me dar algumas instruções, já que estou sem ideias. Estou usando o Docker versão 27.5.1, build 9f9e405

Obrigado!

Tenho um projeto Python que estou desenvolvendo dentro de um devcontainer. A árvore do código-fonte se parece com isso:

---.devcontainer
     |--- .devcontainer.json
     |--- Dockerfile
     |--- requirements.txt
---src
    |--- file1.py
    |--- file2.py

O problema é que ele deve ser lançado em um "contêiner de produção", o que envolve seu próprio Dockerfile e scripts de empacotamento.

Minhas perguntas são:

1. Onde devo colocar o Dockerfile do "contêiner de produção" e os scripts de empacotamento?
2. Onde devo criar o container de produção? Devo executar docker builddentro do container dev?
3. Quando devo executar docker buildpara construir o contêiner de produção?

Estou executando isso para construir localmente uma imagem docker usando o Terraform. Obtém sucesso na primeira execução, mas falha em todas as outras tentativas, Error: failed to read dockerfile: unexpected EOFa menos que eu remova o terraform.tfstatearquivo completa e manualmente.

terraform {
  backend "local" {}
    required_providers {
      docker = {
        source  = "kreuzwerker/docker"
        version = "~>3.0.2"
      }
    # other providers
}
provider "docker" {

}

resource "docker_image" "dbx_kedro_img" {
  name         = "docker-build-test:latest" 
  build {
    context = "."
    dockerfile = "./Dockerfile"
  }
}

Tentei modificar a versão para docker-build-test:latest2ou docker-build-test2:latest, executando terraform state rm docker_image.dbx_kedro_img, removendo as imagens e contêineres do docker locais, sem sucesso. A única coisa que funciona é excluir manualmente o terraform.tfstate. Qualquer ideia é bem-vinda.

docker rm $(docker ps -aq) # not useful
docker rmi $(docker images -q) -f # idem
terraform state rm docker_image.dbx_kedro_img # idem

meu dockerfile:

# Use a lightweight base image
FROM alpine:latest
#
# Set the command to run when the container starts
CMD ["echo", "Hello, World3!"]

EDIT: mesmo comportamento após adicionar um gatilho como este, falha após a primeira tentativa, mesmo ao modificar o nome da imagem.

# not useful
resource "docker_image" "dbx_kedro_img" {
  name         = "docker-build-test5:latest" 
  build {
    context = "."
    dockerfile = "./Dockerfile"
  }
    triggers = {
    always_rebuild = timestamp()
  }
}

Estou um pouco confuso com o comportamento da variável de ambiente $PATHdentro de um contêiner Docker.

• Estou tentando definir a variável $PATH como /kdb/bin, mais alguns outros valores.
• Em vez disso, o valor da $PATHvariável parece estar definido como o mesmo valor do sistema host do Docker Container

O valor de echo $PATHno host é:

$ echo $PATH
/usr/local/bin:/usr/bin:/bin

(Além de algumas outras coisas que omiti por questões de brevidade.)

Aqui está o meu Dockerfile:

FROM ubuntu:24.04
WORKDIR /kdb
ENV QHOME=/kdb
ENV PATH="${QHOME}/bin:${QHOME}:$PATH"
ENV QLIC=/kdb/kc.lic
COPY ./q q
COPY ./bin bin
COPY ./src src
CMD ["/bin/bash", "-c", "sleep infinity"]

e odocker-compose.yml

services:
    kdb:
        container_name: kdb
        build: .
        command: echo $PATH
        ports:
            - 5000:5000

Defini o comando padrão em para docker-compose.ymlser echo $PATH, de modo que o valor de PATHserá mostrado nos logs.

docker logsmostra que o mesmo valor do host está sendo usado dentro do contêiner. A PATHvariável Container não inclui /kdb/binor /kdb.

Por que isso acontece?

Estou construindo um Dockfile e usei isso como conteúdo do arquivo:

FROM ubuntu:20.04
FROM python:3.10.13
FROM pytorch/pytorch:2.1.0-cuda12.1-cudnn8-runtime
WORKDIR /
COPY . .

RUN apt update
RUN apt install -y git
RUN pip install jupyter
RUN pip install transformers

EXPOSE 8888

ENV NAME World

CMD ["jupyter", "notebook", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root"]

Estou usando o Windows 11 e o Windows Subsystem for Linux (WSL). Usei este comando para criar a imagem do Docker:

docker build -t nlp_python:latest .

Quando não o incluí, --gpus allele não funcionou com a GPU quando o testei no Jupyter Notebook, então executei o seguinte comando:

O que funcionou

docker run --gpus all -it -p 8888:8888 nlp_python:latest

Minha pergunta

O que funcionou cria um novo contêiner a cada vez ou há uma modificação desse comando que me permite usar o contêiner que ele criou anteriormente, chamado gracious_feistel?

Espero usar o mesmo contêiner toda vez que executar o comando pelo PowerShell. O resultado desse comando foi que ele criou um novo contêiner, o que estou tentando evitar.