Perguntas[docker](coding)

Estou tentando conectar ao servidor FTP, implantado a partir da imagem do Docker, usando o cliente Apache:

import org.apache.commons.net.ftp.FTPClient

import java.io.IOException

object FtpClient {

  def main(args: Array[String]): Unit = {

    val ftpClient = new FTPClient()

    try {
      ftpClient.connect("localhost", 21)
      val success = ftpClient.login("one", "1234")

      if (success) {
        println("Success connect")
      }

    } catch {
      case e: IOException => throw new RuntimeException(e)
    } finally {
      // 
    }

  }
}

Servidor FTP executado por:

docker run -d     -p 21:21     -p 21000-21010:21000-21010     -e USERS="one|1234"     -e ADDRESS=ftp.site.domain     delfer/alpine-ftp-server

E recebo o seguinte erro:

      Exception in thread "main" java.lang.RuntimeException: org.apache.commons.net.ftp.FTPConnectionClosedException: Connection closed without indication.
at ru.spb.client.FtpClient$.main(FtpClient.scala:23)
at ru.spb.client.FtpClient.main(FtpClient.scala)
     Caused by: org.apache.commons.net.ftp.FTPConnectionClosedException: Connection closed without indication.
at org.apache.commons.net.ftp.FTP.getReply(FTP.java:568)
at org.apache.commons.net.ftp.FTP.getReply(FTP.java:556)

EDITAR:

Os logs do Docker retornam:

Changing password for one
New password: 
Bad password: too short
Retype password: 
adduser: /ftp/one: No such file or directory
passwd: password for one changed by root
seems like pidfd_open syscall does not work, falling back to 
polling
failed to watch for direct child exit (pidfd_open error): Operation not permitted

Talvez eu tenha esquecido alguma configuração de conexão importante?

Estou tentando construir e enviar uma imagem docker. Isso está me dando um erro NU1301: Não foi possível carregar o índice de serviço para a fonte

A estrutura da pasta é a seguinte: src/appfolder/ Na appfolder tenho o Dockerfile e o nuget.config

As próximas duas tarefas que estou tentando usar são:

  - task: DockerInstaller@0
    inputs:
      dockerVersion: '17.09.0-ce'

  - task: Docker@2
    inputs:
      containerRegistry: '$(dockerRegistryServiceConnection)'
      repository: $(imageRepository)
      command: 'buildAndPush'
      Dockerfile: $(dockerfilePath)
      tags: 'latest'
      buildContext: '$(Build.SourcesDirectory)/src'

Veja os arquivos Docker e nuget.config

Estivador:

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 80
EXPOSE 443


# This stage is used to build the service project
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
ARG BUILD_CONFIGURATION=Release
WORKDIR /src
COPY . .
RUN dotnet restore "./appfolder/app.csproj"
WORKDIR "/src/appfolder"
RUN dotnet build "./app.csproj" -c $BUILD_CONFIGURATION -o /app/build

# This stage is used to publish the service project to be copied to the final stage
FROM build AS publish
ARG BUILD_CONFIGURATION=Release
RUN dotnet publish "./app.csproj" -c $BUILD_CONFIGURATION -o /app/publish /p:UseAppHost=false

# This stage is used in production or when running from VS in regular mode (Default when not using the Debug configuration)
FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "app.dll"]

arquivo nuget.config

<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <packageSources>
    <!--To inherit the global NuGet package sources remove the <clear/> line below -->
    <clear />
    <add key="Feed name" value="https://companyname.pkgs.visualstudio.com/project name/_packaging/feedname/nuget/v3/index.json" />
    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
  </packageSources>
  <packageSourceCredentials>
    <companyname>
      <add key="Username" value="my username" />
      <add key="ClearTextPassword" value="my own PAT" />
    </companyname>
  </packageSourceCredentials>
</configuration>

Na guia Configurações do Feed -> permissões, adicionei ambos os usuários do serviço como publicadores do Feed (colaboradores).

Tentei muitas opções, mas comecei com a que descrevi aqui.

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()
  }
}