Criei um servidor web em Go e tentei criar uma imagem docker para fins de aprendizado. Quando inicio a imagem docker, ela não detecta nenhuma variável de ambiente com "docker run", mas se eu iniciar "docker compose", consigo vê-las preenchidas, o que estou perdendo? Não entendi

principal.ir:

func init() {
    fmt.Println("Inizializziamo...")
    cmd := exec.Command("env")
    stdout, err := cmd.Output()
    if err != nil {
        fmt.Println(err.Error())
        return
    }

    // Print the output
    fmt.Println(string(stdout))
}

docker-compose.yml

services:
  blog:
    build: .
    ports:
      - "8080:8080"
    environment:
      - DB_HOST=db
      - DB_PORT=5432
      - DB_USER=test_user
      - DB_PASSWORD=psw
      - DB_NAME=mydb
      - PORT=8080
    depends_on:
      - db

  db:
    image: postgres:15
    restart: always
    environment:
      - POSTGRES_USER=test_user
      - POSTGRES_PASSWORD=psw
      - POSTGRES_DB=mydb
    ports:
      - "5432:5432"
    volumes:
      - db-data:/var/lib/postgresql/data

volumes:
  db-data:

# docker compose run --rm blog env
[+] Creating 1/0
 ✔ Container mywebserver-db-1  Running                                                                                                                                                                                                                                   0.0s 
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
HOSTNAME=154d98c6277d
TERM=xterm
DB_PASSWORD=psw
DB_NAME=mydb
PORT=8080
DB_HOST=db
DB_PORT=5432
DB_USER=test_user
HOME=/root

com docker run sem variáveis ​​env

# docker run xxxx/mywebserver
Inizializziamo...
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
HOSTNAME=0f42e93ff038
HOME=/root

estou fazendo algo errado? Obrigado pela ajuda

O frontend abre em https, acessa o backend em my_domain/api/start, mas a resposta não é retornada e há um erro no console:

GET https://my_domain.com:8082/api/start net::ERR_SSL_PROTOCOL_ERROR

Aqui está meu nginx.conf:

server {
    listen 80;
    server_name my_domain.com www.my_domain.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl;
    server_name my_domain.com www.my_domain.com;

    root /usr/share/nginx/html;
    index index.html;

    ssl_certificate /etc/nginx/ssl/certificate.crt;
    ssl_certificate_key /etc/nginx/ssl/private.key;

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:HIGH:!aNULL:!MD5;

    # API Backend proxy
    location /api/ {
        proxy_pass http://backend:8082;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    location / {
        try_files $uri $uri/ /index.html;
    }

    error_page 404 /index.html;
}

Minha composição:

services:
  frontend:
    build:
     context: ./frontend
     args:
      NGINX_CONF: ${NGINX_CONF}
#    network_mode: host
#    depends_on:
#      - backend
    ports:
      - '80:80'
      - "443:443"
    volumes:
      - ./frontend/ssl:/etc/nginx/ssl
    environment:
      - ENVIRONMENT=${ENVIRONMENT}
  backend:
    build:
     context: ./backend
     args:
      CONFIG: ${CONFIG}
    ports:
      - '8082:8082'
      - '8443:8443'
    volumes:
      - ./frontend/ssl:/etc/nginx/ssl
    environment:
      - ENVIRONMENT=${ENVIRONMENT}

networks:
  app-network:
    driver: bridge

curl por http://my_domain:8082/api/start responde normalmente, sem erros. Tentei muitas variantes e nada muda.

Estou tentando conteinerizar um aplicativo Blazor sabendo que tenho o Serverprojeto e o Clientprojeto.

Eu queria saber se devo clicar com o botão direito do mouse no Serverprojeto e criar um Dockerfile apenas para o projeto do servidor, sabendo que o Blazor é basicamente um tipo de projeto de 2 projetos em 1, ou se o Clientprojeto também precisa de seu próprio Dockerfile (e, portanto, talvez precise ser executado com o Docker Compose para poder se comunicar)?

Estou tentando dockerizar um aplicativo .NET 8.0. Embora o exemplo do .NET 7.0 que encontrei funcione bem, tenho problemas para fazer o mesmo com o .NET 8.0.

É isso que eu executo e o erro que recebo:

docker build -f Dockerfile -t my-app ..
Sending build context to Docker daemon  18.51MB
Step 1/11 : FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
8.0: Pulling from dotnet/sdk
no matching manifest for windows/amd64 10.0.20348 in the manifest list entries

Ao tentar forçar a plataforma, tenho o mesmo problema

docker build --platform windows/amd64 -f Dockerfile -t my-app .. 
Sending build context to Docker daemon  18.51MB
Step 1/11 : FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
8.0: Pulling from dotnet/sdk
no matching manifest for windows/amd64 10.0.20348 in the manifest list entries

Obrigado pela sua ajuda neste caso

Estou tentando usar kubectldentro krewde um contêiner Docker. Aqui está meu Dockerfile:

FROM alpine:latest
ENV KUBECTL_VERSION=v1.30.5 KREW_VERSION=v0.4.4
RUN apk update && apk add --no-cache curl bash git \
    && curl -LO "https://dl.k8s.io/release/${KUBECTL_VERSION}/bin/linux/amd64/kubectl" \
    && chmod +x kubectl && mv kubectl /usr/local/bin/ \
    && curl -fsSL "https://github.com/kubernetes-sigs/krew/releases/download/${KREW_VERSION}/krew-linux_amd64.tar.gz" | tar xz -C /tmp \
    && mv /tmp/krew-* /usr/local/bin/krew \
    && /usr/local/bin/krew install konfig
ENV PATH="/root/.krew/bin:${PATH}"
CMD ["tail", "-f", "/dev/null"]

Passos que segui:

1. Construiu a imagem:docker build -t kubectl-krew .
2. Executei o contêiner:docker run -it kubectl-krew
3. Dentro do recipiente:
   • kubectl versionobras e shows:

     Client Version: v1.30.5
     Kustomize Version: v5.0.4-0.20230601165947-6ce0bf390ce3
     The connection to the server localhost:8080 was refused - did you specify the right host or port?
     

   • krew versionmostra:

     OPTION            VALUE
     GitTag            v0.4.4
     GitCommit         343e657
     IndexURI          https://github.com/kubernetes-sigs/krew-index.git
     BasePath          /root/.krew
     IndexPath         /root/.krew/index/default
     InstallPath       /root/.krew/store
     BinPath           /root/.krew/bin
     DetectedPlatform  linux/amd64
     

   • Mas kubectl krew updatefalha com:
     error: unknown command "krew" for "kubectl"

A variável de ambiente $PATHé:
/root/.krew/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin.

Por que não é kubectl krewreconhecido? Como posso consertar isso?

No momento, estou configurando um servidor HTTPS com Go usando uma assinatura autoassinada armazenada em cert.peme key.pempara desenvolvimento. Sempre que executo o servidor localmente, ele funciona muito bem, permitindo que eu me conecte ao meu servidor HTTPS. No entanto, quando construo meu Dockerfile e o executo de lá, meu navegador retorna esta página:

Continuo tentando usar ADDe COPYcom os dois arquivos no meu Dockerfile porque não tenho certeza se ele está sendo incluído no meu projeto Go depois de ser construído, mas sempre que tento construir o Dockerfile modificado, ele me dá um erro que diz que não consegue encontrar os arquivos. O comando docker que estou executando é sudo docker run -p 8080:8080 hxgo-skeleton. Como adiciono os arquivos cert.peme key.pemno meu Dockerfile para um servidor web Golang?

Arquivo Docker

# Build
FROM golang:1.23.3-alpine AS build-env
ENV APP_NAME=hxgo-skeleton
ENV CMD_PATH=cmd/api/main.go
COPY . $GOPATH/src/$APP_NAME
COPY .env $GOPATH/src/$APP_NAME
WORKDIR $GOPATH/src/$APP_NAME

# Building the Go application
RUN CGO_ENABLED=0 go build -v -o /$APP_NAME $GOPATH/src/$APP_NAME/$CMD_PATH
 
# Run
FROM alpine:3.14
ENV APP_NAME=hxgo-skeleton
COPY --from=build-env /$APP_NAME .
COPY .env .
EXPOSE 8080
CMD ./$APP_NAME

Pelo que entendi, eu deveria conseguir executar um script de shell ao criar um contêiner, copiando-o para o diretório /docker-entrypoint-initdb.d por meio do meu Dockerfile.

O problema que tenho é que depois de executar o docker compose up, recebo o seguinte erro -

mysql_container-1  | 2024-12-16 21:14:21+00:00 [Note] [Entrypoint]: /usr/local/bin/docker-entrypoint.sh: running /docker-entrypoint-initdb.d/shell.sh                                                     
mysql_container-1  | touch: cannot touch '/mysql_server/test': Permission denied

Eu esperava que o script de shell fosse executado e criasse um arquivo chamado test. Confusamente, consegui remover esse script do meu Dockerfile e executar no contêiner e tocar em um arquivo sem problemas. Também tentei adicionar RUN ["chmod", "u+x", "/docker-entrypoint-initdb.d/shell.sh"]ao meu Dockerfile sem sucesso. Veja meus arquivos docker-compose.yml, Dockerfile e shell.sh abaixo.

TIA por qualquer ajuda ou orientação sobre isso.

Arquivo Docker:

FROM mysql:lts
WORKDIR /mysql_server

COPY shell.sh /docker-entrypoint-initdb.d
RUN ["chmod", "u+x", "/docker-entrypoint-initdb.d/shell.sh"]

docker-compose.yml:

services:
  mysql_container:
    image: mysql_image:Dockerfile
    build: 
      context: .
    ports:
      - "3306:3306"
    environment:
      - MYSQL_ALLOW_EMPTY_PASSWORD=yes
      - MYSQL_DATABASE=docker_db

shell.sh:

#!/bin/sh
touch /mysql_server/test

O aplicativo Next.js agrupa as variáveis ​​env durante o tempo de construção. É por isso que preciso passar variáveis ​​env como args e usá-las durante o estágio de construção. Agora, como parte do pipeline CD/CI, quero passar args dinamicamente por meio de variáveis ​​de ambiente declaradas em compose.yaml. No entanto, a variável env do arquivo compose não é lida durante o tempo de construção. Na verdade, o terminal imprime a seguinte mensagem:

time="2024-12-12T23:35:10-05:00" level=warning msg="A variável "NEXT_PUBLIC_GRAPHQL_SERVER" não está definida. Padrão para uma string em branco."

Compor.yaml

services:
  frontend:
    build:
      context: ./frontend
      args:
        - NEXT_PUBLIC_GRAPHQL_SERVER=${NEXT_PUBLIC_GRAPHQL_SERVER}
    env_file:
      - ./frontend/.env
    environment:
      NODE_ENV: production
      NEXT_PUBLIC_GRAPHQL_SERVER: http://localhost:3000/
    ports:
      - 8080:8080

arquivo docker:

FROM base AS builder
WORKDIR /usr/src/app

COPY --from=deps /usr/src/app/node_modules ./node_modules
COPY . .
ARG NEXT_PUBLIC_GRAPHQL_SERVER
ENV NEXT_PUBLIC_GRAPHQL_SERVER=${NEXT_PUBLIC_GRAPHQL_SERVER}
RUN npm run build

Tudo funciona bem quando defino explicitamente a variável env em args, mas esse não é o fluxo de trabalho desejado.

services:
  frontend:
    build:
      context: ./frontend
      args:
        - NEXT_PUBLIC_GRAPHQL_SERVER=http://localhost:3000/

Estou usando builder.AddPostgres().WithImage(...), mas a imagem tem esse comportamento de sair se eu não usar -itao fazerdocker run

é assim que a documentação diz para usar esta imagem:

docker run \
    -it \
    -v postgresml_data:/var/lib/postgresql \
    -p 5433:5432 \
    -p 8000:8000 \
    ghcr.io/postgresml/postgresml:2.7.12 \
    sudo -u postgresml psql -d postgresml

é assim que adiciono o postgres, mas o seed não funciona, o item é mostrado no painel como encerrado e no docker se eu pressionar o botão de reprodução ele simplesmente inicia e sai em menos de um minuto, que é a maneira correta de manter o contêiner em execução.

    postgres = builder.AddPostgres("lcommerce-dependecy-postgres", port: 5432)
        .WithImage("postgresml/postgresml")
        .WithImageTag("2.9.3")
        .WithImageRegistry("ghcr.io")
        .WithHttpEndpoint(name: "endpoint-55432-5432",
            port: 8000, targetPort: 8000, isProxied: true)
        .WithContainerRuntimeArgs("-it", "--gpus=all");

Tentei manter o contêiner em execução usando, .WithContainerRuntimeArgs("-it", "--gpus=all")mas continuo saindo. (por padrão, o net aspire adiciona usuário e senha do postgres. Já testei outra imagem pgvector/pgvectore funciona bem, mas esta não sai por padrão)

ATUALIZAR

VOCÊ PODE USAR

.WithContainerRuntimeArgs("-i", "--gpus=all")
.WithArgs("sudo", "-u", "postgresml", "psql", "-d", "postgresml")

MAS O MELHOR É

(como a resposta sugere):

.WithContainerRuntimeArgs("--gpus=all")
.WithArgs( "sleep","infinity")

O CORRETO É

Crie uma imagem personalizada com a extensão e os módulos necessários e defina o servidor de banco de dados como o principal processo persistente em vez de usar uma solução alternativa (como a resposta mencionou)

Então eu tenho um VPS que expõe um endpoint de API no host local na porta 8080.

Tenho um aplicativo Svelte que precisa do endpoint. Para construir o aplicativo Svelte que estou usando docker-compose.yamlcom

version: '3.8'

services:
  frontend:
    build:
      context: ./frontend
      target: development
    volumes:
      - ./frontend:/app
      - /app/node_modules
    ports:
      - "5173:5173"
    environment:
      - NODE_ENV=development

e dentro da pasta frontend tenho o arquivo Docker

FROM node:23-alpine as development

WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .

EXPOSE 5173
CMD ["npm", "run", "dev", "--", "--host"]

FROM node:23-alpine as build
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

FROM nginx:alpine as production
COPY --from=build /app/dist /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

Com essa configuração, o Svelteapp parece incapaz de acessar o host local na máquina host. A única maneira de acessá-lo foi adicionar a linha network_mode: hostao docker-compose. yaml. Dessa forma, consegui acessar o IP do host local diretamente com 192.168.1.17 , que é o IP em toda a minha rede local.

Existe uma maneira de acessar o IP do host localhost diretamente usando localhosta palavra-chave do contêiner ou simplesmente não codificar o IP, o que pode mudar