Докерна розробка Deep Dive: Від базових до складних .NET Containerization (Українська (Ukrainian))

Докерна розробка Deep Dive: Від базових до складних .NET Containerization

Sunday, 09 November 2025

//

48 minute read

Введение

Докер фундаментально змінив те, як ми будуємо, корабель, і запускаємо додаткиM SK2 Те, що почалося як простий інструмент контейнеризації, перетворилося на цілковиту екосистему для розвитку та застосування сучасних програм

Це четвертий і найголовніший artykuł в моїй серії докерів для . NET разработчиківM SK1 Якщо ви ' є новими в Dockerі, ви можете почати з МSK4

  1. Докер Compose - Почнемо з базових настроїв для контейнерів з мультикомп 'ютерами -
  2. Розробка залежностей з комп 'ютером Docker - Налагодження локального dev-простору Август МSK2
  3. Створити зображення з дротом - розв 'язання проблем з дозволенням на об' єм МSK1Август МSK2

У цьому глибокому зануренні ми збудуємо ці основи для дослідження

  • Produkція- Готовий комп 'ютер Docker: Фактичний стег, що запускає цей блог
  • Self- хостинг на обмежених ресурсах: Практичні методи оптимізації бюджетнихVPS
  • Obsługа GPU: Практика з навантаженнями ML у контейнерах
  • Мультиконструкції: Obsługа ARM
  • .NET МSK1 характеристики контейнерів: Сконструйовано- в контейнері для публікації без Dockerfiles
  • .NET Aspire: Современная концепція .NET для оркестрування контейнерів

NOTE: Це частина моїх експериментів з штучним інтелектом.

Неважливо, чи ви' розробляєте просту веб-програму або організуєте складну мікросервісну архітектуру з допомогою ҐПУ(GPU)

Фундаментали Докера: Порозуміння контейнерів

Що таке Docker, НасправдіM SK1

На основі, Докер - це платформа для контейнеризації, яка упакує вашу програму та всі її залежності в стандартизовану установку, яка називається контейнером . На відміну від віртуальних машин, які вибудовують цілу операційну систему МSK2 контейнери діляться ядром хоста, зберігаючи ізольовані простір для користувачів

Подумайте ось так.

  • Виртуальні машини: Кожна VM запускає повний стек ОС ( Лінуксовий ядра МSK2 системні библиотеки МSK3 і т.д.
  • Контейнери: Поділитись ядром-хозяїком МSK1 пакетом лише код та відданість МSK2 легкий і швидкий

Чому контейнери важливі для розробників

# The classic developer problem
"It works on my machine!" 

# The container solution
"Ship your machine!" 

Контейнери розв 'язують декілька важливих проблем:

  1. Сpójність з навколишнім середовищем: розвиток , тестування МSK2 і виробничі умови однакові
  2. Ісоляція залежності: Ніхто більше "DLL hell" або суперечливі версії бібліотеки
  3. Повторювані будинки: Один і той самий вхід
  4. швидке розгортання: Запуск контейнерів за секунду , не хвилин
  5. Efektivність використання ресурсів: Запуск десятків контейнерів на одному хосте

Невід 'ємні концепції Докера

Зображення проти контейнерів

# An image is a template (like a class in OOP)
docker pull mcr.microsoft.com/dotnet/aspnet:9.0

# A container is a running instance (like an object)
docker run -d -p 8080:8080 myapp:latest

Фото є незмінними, шарові файлові системиM SK1 Кожна інструкція в Dockerfile створює новий шар:

FROM mcr.microsoft.com/dotnet/aspnet:9.0      # Layer 1: Base OS + .NET runtime
WORKDIR /app                                   # Layer 2: Directory structure
COPY *.dll ./                                  # Layer 3: Application files
ENTRYPOINT ["dotnet", "MyApp.dll"]            # Layer 4: Startup command

Цей шарування потужний:

  • Камера: Невимінні шари перероблені , пришвидшують будування
  • Об 'єднання: Багато зображення можуть ділитися базовими шарами
  • Ефективність: Потрібно завантажити лише зміни шарів

Усвідомлення процесу виконання Dockerfile: Не ваша машина!

Поширена причина збентеження для новаторів Docker: Команди в Dockerfile не запускаються на вашій машині. - вони запускаються всередині контейнера збудування.

Ось що насправді відбувається

Your Machine (Windows/Mac/Linux)
    ↓ (reads Dockerfile)
Build Image (usually Linux)
    ↓ (executes RUN commands here)
Output Image (contains results)

Чому це важливо:

# You're on Windows, writing this Dockerfile
FROM ubuntu:24.04

# This RUN command executes in Ubuntu, NOT on your Windows machine!
RUN apt-get update && apt-get install -y curl

# This copies FROM your Windows filesystem
COPY myapp.exe /app/

# This executes IN the Ubuntu container
RUN chmod +x /app/myapp.exe

Найголовні ідеї:

  1. Локальна файлова система: Ваша COPY і ADD команди читаються з вашої машини
  2. Збудувати зображення: Ваша RUN команди виконувати в контейнері's OS (не на вашій машині )
  3. Виходний образ: Остання зображення містить всі шари, створені під час будування
  4. Крестова платформа: Ви можете знаходитись на Windows , створюючи зображення Linux МSK2 за допомогою Linux команд

Ось чому ви можете писати apt-get команди в Dockerfile на Windows - вони ' не працюють на Windows

Наприклад, сценарій заплутаності:

FROM mcr.microsoft.com/dotnet/sdk:9.0  # This is Linux-based

# You might think: "But I'm on Windows, how can I use these Linux commands?"
RUN apt-get update  # ← Executes in the Linux build container, not your Windows machine
RUN dotnet restore  # ← Executes in the Linux build container

Даemon Докер керує перекладом між локальною файловою системою і контейнеризованою будівлю.

Найкращі практики Dockerfile

Тут – МСК0 – це виробництво, МСК1 – готовий, МSK2 – NET Dockerfile з komentarzом, МСК3

# Multi-stage build: separates build environment from runtime
# Stage 1: Build
FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build
WORKDIR /src

# Copy only csproj files first (better layer caching)
COPY ["MyApp/MyApp.csproj", "MyApp/"]
COPY ["MyApp.Core/MyApp.Core.csproj", "MyApp.Core/"]

# Restore dependencies (cached unless csproj changes)
RUN dotnet restore "MyApp/MyApp.csproj"

# Copy everything else
COPY . .

# Build the application
WORKDIR "/src/MyApp"
RUN dotnet build "MyApp.csproj" -c Release -o /app/build

# Stage 2: Publish
FROM build AS publish
RUN dotnet publish "MyApp.csproj" -c Release -o /app/publish /p:UseAppHost=false

# Stage 3: Final runtime image
FROM mcr.microsoft.com/dotnet/aspnet:9.0 AS final
WORKDIR /app

# Create non-root user for security
RUN addgroup --gid 1001 appuser && \
    adduser --uid 1001 --gid 1001 --disabled-password --gecos "" appuser

# Copy published output from publish stage
COPY --from=publish /app/publish .

# Switch to non-root user
USER appuser

# Expose port (documentation only, doesn't actually publish)
EXPOSE 8080

# Set environment variables
ENV ASPNETCORE_URLS=http://+:8080
ENV ASPNETCORE_ENVIRONMENT=Production

# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
    CMD curl -f http://localhost:8080/health || exit 1

ENTRYPOINT ["dotnet", "MyApp.dll"]

Усвідомлення потоку будування

Ось що насправді відбувається під час розробки багатоканального докера

graph TB
    subgraph "Your Machine"
        A[Source Code<br/>*.cs, *.csproj]
        B[Frontend Assets<br/>*.js, *.css]
        C[Configuration<br/>appsettings.json]
        D[Static Files<br/>wwwroot/]
    end

    subgraph "Stage 1: Build Container (SDK Image)"
        E[dotnet/sdk:9.0<br/>~1.5GB]
        F[Copy .csproj files]
        G[dotnet restore<br/>Download NuGet packages]
        H[Copy source code]
        I[dotnet build<br/>Compile to DLLs]
        J[Build artifacts<br/>/app/build/]
    end

    subgraph "Stage 2: Publish Container"
        K[dotnet publish<br/>Optimize & trim]
        L[Published output<br/>/app/publish/]
    end

    subgraph "Stage 3: Final Runtime Container (ASPNET Image)"
        M[dotnet/aspnet:9.0<br/>~220MB]
        N[Create app user<br/>Security]
        O[Copy published files<br/>ONLY production artifacts]
        P[Final image<br/>~250MB total]
    end

    subgraph "Frontend Build Pipeline (Parallel)"
        Q[npm install<br/>node_modules/]
        R[Webpack bundling<br/>*.js → dist/]
        S[TailwindCSS + PostCSS<br/>*.css → dist/]
        T[Optimized assets<br/>wwwroot/js/dist/<br/>wwwroot/css/dist/]
    end

    A --> F
    A --> H
    F --> G
    G --> H
    H --> I
    I --> J
    J --> K
    K --> L

    B --> Q
    Q --> R
    Q --> S
    R --> T
    S --> T

    L --> O
    T --> O
    C --> O
    D --> O

    M --> N
    N --> O
    O --> P

Найголовні ідеї з цього потоку:

  1. Зображення SDK відкинуто: Контейнер SDK МSK1 ГБ викидається після публікації МSK2 лише ~50 Мб компілірованої інформації рухається вперед
  2. Захмарування шарів: копіювання .csproj перед тим, як вихідний код значить, що відновлення залежності буде вキャッシュі, якщо залежність не зміниться
  3. Фронт-енд: Збудовано окремо ( часто через npm run build) і копіюється на кінцевий знімок
  4. Файлі конфігурації: appsettings.json і wwwroot/ контент копіований з вашої машини, не збудований
  5. Остання картина: Розпочинається з мінімального зображення пробігу часу МSK1МБМСК2 МСК3 ваші додатки
  6. Тільки production files: вихідний код , obj/, binM SK3 вузолMST4 модуліM ST5 ніколи не дістаються до кінцевого зображення

Головні принципи ілюстровані:

  1. Мультирівні будинки: Separate buildM SK1publish stages dramatically reduce final image size
  2. Оптимізація шарів: Копуйте файли залежності перед кодом для кращого кэшування
  3. Безпека: Працювати як не пользователь
  4. Проверки здоров 'я: Оркестратори контейнерів можуть контролювати здоров 'я aplikacji
  5. Очевидне середовище: Установити початкові стандарти виробництва

Збудова та запуск

# Build the image
docker build -t myapp:1.0.0 -t myapp:latest .

# Run with common options
docker run -d \
  --name myapp \
  -p 8080:8080 \
  -e ConnectionStrings__DefaultConnection="Server=db;Database=myapp" \
  -v /data/logs:/app/logs \
  --restart unless-stopped \
  myapp:latest

# View logs
docker logs -f myapp

# Execute commands inside running container
docker exec -it myapp /bin/bash

# Stop and remove
docker stop myapp
docker rm myapp

Докер комп 'ютера: МультиконтурніM SK1 Оркестрування контейнера

Докер Compose дозволяє вам визначити та запускати багатоконтейнерівні додатки-Container applications. Замість того, щоб керувати контейнерами окремоM SK2 ви описуєте весь стег доданок у файлі YAML

Чому Docker Compose

Розглянемо типову веб-програму .NET

  • ASP.NET Коренная веб-програма
  • База даних PostgreSQL
  • Редіс-каш
  • Seq для журналування
  • Можливо, служба

керувати цими окремими docker run команди стають неважливими. Docker Compose вирішує це.

Полне реальне- Світовий приклад : Платформа для створення блогу

Ось так: справжнє виробництво docker-compose.yml що запускає цей самий сайт. (mostlylucid

services:
  # Main ASP.NET Core application
  mostlylucid:
    image: scottgal/mostlylucid:latest
    restart: always
    healthcheck:
      test: [ "CMD", "curl", "-f -K", "https://mostlylucid:7240/healthy" ]
      interval: 30s
      timeout: 10s
      retries: 5
    labels:
      - "com.centurylinklabs.watchtower.enable=true"
    env_file:
      - .env
    environment:
      - Auth__GoogleClientId=${AUTH_GOOGLECLIENTID}
      - Auth__GoogleClientSecret=${AUTH_GOOGLECLIENTSECRET}
      - Auth__AdminUserGoogleId=${AUTH_ADMINUSERGOOGLEID}
      - SmtpSettings__UserName=${SMTPSETTINGS_USERNAME}
      - SmtpSettings__Password=${SMTPSETTINGS_PASSWORD}
      - Analytics__UmamiPath=${ANALYTICS_UMAMIPATH}
      - Analytics__WebsiteId=${ANALYTICS_WEBSITEID}
      - ConnectionStrings__DefaultConnection=${POSTGRES_CONNECTIONSTRING}
      - TranslateService__ServiceIPs=${EASYNMT_IPS}
      - Serilog__WriteTo__0__Args__apiKey=${SEQ_API_KEY}
      - Markdown__MarkdownPath=${MARKDOWN_MARKDOWNPATH}
    volumes:
      - /mnt/imagecache:/app/wwwroot/cache
      - /mnt/logs:/app/logs
      - /mnt/markdown:/app/markdown
      - ./mostlylucid.pfx:/app/mostlylucid.pfx
      - /mnt/articleimages:/app/wwwroot/articleimages
      - /mnt/mostlylucid/uploads:/app/wwwroot/uploads
    networks:
      - app_network
    depends_on:
      - db

  # PostgreSQL database
  db:
    image: postgres:16-alpine
    ports:
      - 5266:5432  # Custom external port to avoid conflicts
    env_file:
      - .env
    networks:
      - app_network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER}"]
      interval: 5s
      timeout: 5s
      retries: 5
    volumes:
      - /mnt/umami/postgres:/var/lib/postgresql/data
    restart: always

  # Cloudflare tunnel for secure external access
  cloudflared:
    image: cloudflare/cloudflared:latest
    command: tunnel --no-autoupdate run --token ${CLOUDFLARED_TOKEN}
    env_file:
      - .env
    restart: always
    networks:
      - app_network

  # Umami analytics
  umami:
    image: ghcr.io/umami-software/umami:postgresql-latest
    env_file: .env
    environment:
      DATABASE_URL: ${DATABASE_URL}
      DATABASE_TYPE: ${DATABASE_TYPE}
      HASH_SALT: ${HASH_SALT}
      APP_SECRET: ${APP_SECRET}
      TRACKER_SCRIPT_NAME: getinfo
      API_COLLECT_ENDPOINT: all
    depends_on:
      - db
    labels:
      - "com.centurylinklabs.watchtower.enable=true"
    networks:
      - app_network
    restart: always

  # Translation service (CPU-limited for resource management)
  easynmt:
    image: easynmt/api:2.0.2-cpu
    volumes:
      - /mnt/easynmt:/cache/
    deploy:
      resources:
        limits:
          cpus: "4.0"  # Prevent translation service from consuming all CPU
    networks:
      - app_network

  # Caddy reverse proxy with automatic HTTPS
  caddy:
    image: caddy:latest
    ports:
      - 80:80
      - 443:443
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile
      - caddy_data:/data
      - caddy_config:/config
    networks:
      - app_network
    restart: always

  # Seq centralized logging
  seq:
    image: datalust/seq
    container_name: seq
    restart: unless-stopped
    environment:
      ACCEPT_EULA: "Y"
      SEQ_FIRSTRUN_ADMINPASSWORDHASH: ${SEQ_DEFAULT_HASH}
    volumes:
      - /mnt/seq:/data
    networks:
      - app_network

  # Prometheus metrics collection
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - prometheus-data:/prometheus
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
    labels:
      - "com.centurylinklabs.watchtower.enable=true"
    networks:
      - app_network

  # Grafana visualization
  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    labels:
      - "com.centurylinklabs.watchtower.enable=true"
    volumes:
      - grafana-data:/var/lib/grafana
    networks:
      - app_network
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD}

  # Host metrics exporter
  node_exporter:
    image: quay.io/prometheus/node-exporter:latest
    container_name: node_exporter
    command:
      - '--path.rootfs=/host'
    networks:
      - app_network
    restart: unless-stopped
    volumes:
      - '/:/host:ro,rslave'

  # Automatic container updates
  watchtower:
    image: containrrr/watchtower
    container_name: watchtower
    restart: always
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - WATCHTOWER_CLEANUP=true
      - WATCHTOWER_LABEL_ENABLE=true
    command: --interval 300  # Check every 5 minutes

volumes:
  grafana-data:
  caddy_data:
  caddy_config:
  prometheus-data:

networks:
  app_network:
    driver: bridge

Ключові моделі виробництва:

  1. Одна мережа: Всі послуги на app_network для простоти
  2. Об 'єднати підвіски: Хозяйські шляхи (/mnt/*) для стійких даних, які вам потрібні для резервного копуванняM SK1доступ
  3. Наименовані томи: Докер - підпорядкована зберігання для даних, які ви не маєте МSK2 не потребує прямого доступу до
  4. Наклейки на вежі спостереження: Лише ті сервіси, що відображають елемент для автоM SK1update
  5. Ресурсні обмеження: Конsträngії процесора на перекладовій послугі запобігають голоду ресурсів
  6. Внешне картування портів: PostgreSQL на 5266 замість МSK2, щоб уникнути конфліктів з іншими instancjami
  7. Файлі середовища: Тайни в .env файл (ніколи не обіцявся на git)

Докер Compose Key Features

Залежність від послуг

services:
  web:
    depends_on:
      db:
        condition: service_healthy  # Wait for health check
      redis:
        condition: service_started  # Just wait for start

Докер Compose організовує порядок запуску. condition: service_healthy необхідно пройти медичну перевірку бази даних перед запуском веб-приложения.

Варіабли та секрети довкілля

# .env file (never commit to git!)
DB_PASSWORD=super_secret_password
SMTP_PASSWORD=another_secret
services:
  web:
    environment:
      - DB_PASSWORD=${DB_PASSWORD}  # From .env file
      - STATIC_VALUE=production     # Hardcoded
    env_file:
      - .env                        # Load entire file

Для секретів виробництва, використовуйте Docker Secrets або внешні секретні менеджери (AWS Secrets Manager, Azure Key VaultM SK3 HashiCorp Vault≥).

Наименовані томи проти за Bind Mounts

services:
  db:
    volumes:
      # Named volume (managed by Docker)
      - postgres_data:/var/lib/postgresql/data

  web:
    volumes:
      # Bind mount (maps host directory to container)
      - ./data/markdown:/app/Markdown
      - ./logs:/app/logs

Наименовані томи:

  • Менеджером є Докер
  • Перетримування даних через контейнер знову починається
  • Можна підтримувати/ відновити з командами Докера
  • Cross-платформенний комп 'ютер

Закріплення в кільці:

  • Пряме нанесення на файлову систему хоста
  • Досить для розвитку (live code reloadingM SK1
  • Файлі конфігурації, журналиМSK1 завантаження

Мережа

networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge

services:
  web:
    networks:
      - frontend
      - backend

  db:
    networks:
      - backend  # Not exposed to frontend

Мережі zapewniaють ізоляцію. ТутМSK1 база даних доступна лише для західних послугМСК2 не безпосередньо відкритаМ СК3

Проверки здоров 'я

services:
  db:
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s

Контроль здоров 'я дозволяє Dockerу::

  • Визначати, чи контейнер дійсно готовий (не тільки розпочавсяM SK1
  • Знову запускати нездорові контейнери
  • Дайте статус оркестраторам (KubernetesM SK1 Docker Swarm)

Поширені Commands Compose Docker

# Start all services (detached)
docker-compose up -d

# Start specific services
docker-compose up -d web db

# View logs (all services)
docker-compose logs -f

# View logs (specific service)
docker-compose logs -f web

# Stop services (containers remain)
docker-compose stop

# Stop and remove containers
docker-compose down

# Stop, remove containers, and remove volumes
docker-compose down -v

# Rebuild and restart
docker-compose up -d --build

# Scale a service
docker-compose up -d --scale worker=3

# Execute command in running service
docker-compose exec web /bin/bash

# Run one-off command
docker-compose run --rm web dotnet ef database update

Розробка проти виробництва Комп 'ютерні файли

Відокремлені проблеми з багатьма файлами комп 'ютера:

докер-композиціяM SK1yml (базаМSK1

services:
  web:
    build: .
    environment:
      - ASPNETCORE_ENVIRONMENT=Development

докер-конструкціяМSK1переходникM SK2мл (розробка МSK1авто-мобільна МSK2з 'єднана ):

services:
  web:
    volumes:
      - .:/app  # Live code reloading
    ports:
      - "5000:8080"

докер-конструкціяM SK1продукціяМSK2мл МSK0продуктивність):

services:
  web:
    image: registry.example.com/myapp:${VERSION}
    restart: always
    deploy:
      replicas: 3
      resources:
        limits:
          cpus: '2'
          memory: 2G
# Development (base + override)
docker-compose up -d

# Production
docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d

Obsługа GPU у Dockerі: Швидшення obciążeń ML

Машинне навчання, наукове обчисленняM SK1 і програми обробки відео часто потребують прискорення GPU. Докер підтримує NVIDIA GPU за допомогою NVIDIA Container Toolkit

Налагодження комплекту інструментів для контейнерів NVIDIA

# Install NVIDIA Container Toolkit (Ubuntu/Debian)
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -s -L https://nvidia.github.io/libnvidia-container/gpgkey | sudo apt-key add -
curl -s -L https://nvidia.github.io/libnvidia-container/$distribution/libnvidia-container.list | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

sudo apt-get update
sudo apt-get install -y nvidia-container-toolkit

# Configure Docker daemon
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

# Test GPU access
docker run --rm --gpus all nvidia/cuda:12.6.0-base-ubuntu24.04 nvidia-smi

Dockerfile for GPU-Accelerated Python/PyTorch Application

# Use NVIDIA CUDA base image
FROM nvidia/cuda:12.6.0-cudnn-runtime-ubuntu24.04

# Install Python
RUN apt-get update && apt-get install -y \
    python3.12 \
    python3-pip \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app

# Install PyTorch with CUDA support
COPY requirements.txt .
RUN pip3 install --no-cache-dir torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

# Copy application
COPY . .

# Test GPU on container start
RUN python3 -c "import torch; print(f'CUDA available: {torch.cuda.is_available()}'); print(f'GPU: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else \"None\"}')"

ENTRYPOINT ["python3", "train.py"]

Ввімкнені контейнери GPU

# Run with all GPUs
docker run --gpus all myapp:gpu

# Run with specific GPUs
docker run --gpus '"device=0,2"' myapp:gpu

# Run with GPU memory limits
docker run --gpus all --memory=16g myapp:gpu

ГПУ в комп 'ютері Докера

services:
  ml-trainer:
    build:
      context: .
      dockerfile: Dockerfile.gpu
    image: myapp:gpu
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all  # or specific count: 1, 2, etc.
              capabilities: [gpu]
    volumes:
      - ./models:/app/models
      - ./data:/app/data
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
      - CUDA_VISIBLE_DEVICES=0,1  # Use GPUs 0 and 1

real-World Example: Translation Service with GPU and CPU Builds

Ось реальний приклад виробництва найбільш зрозуміле-nmt, я створив послугу перекладу нейронних машин, яка дає можливість автоматичним - перекладам на цьому блогі

Проект демонструє

  • Варіанти GPU та CPU - Схожа база коду , різні зображення
  • Мультиконструкції - Obsługує AMD64 і ARMM SK2
  • Оптимовані зображення Докера - Як повні, так і мінімальні варіанти
  • Produkція- готова - Здоров 'яні перевірки , тривалість об' єму МSK2 правильне фіксування

GPU-Accelerated Translation Service

services:
  translation:
    image: scottgal/mostlylucid-nmt:gpu
    container_name: translation-gpu
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    environment:
      - MODEL_FAMILY=opus-mt
      - FALLBACK_MODELS=mbart50,m2m100
      - CUDA_VISIBLE_DEVICES=0
      - LOG_LEVEL=info
    volumes:
      - model_cache:/app/cache  # Persistent model storage
    ports:
      - "8888:8888"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8888/health"]
      interval: 30s
      timeout: 10s
      retries: 3

volumes:
  model_cache:

Або лише альтернатива

Для об 'єктів без ҐПУ, одна і та сама служба працює на ЦПУМSK1

services:
  translation:
    image: scottgal/mostlylucid-nmt:cpu
    container_name: translation-cpu
    environment:
      - MODEL_FAMILY=opus-mt
      - FALLBACK_MODELS=mbart50,m2m100
    volumes:
      - model_cache:/app/cache
    ports:
      - "8888:8888"
    restart: unless-stopped

volumes:
  model_cache:

Доступні варіанти зображення:

  • scottgal/mostlylucid-nmt:gpu - CUDA 12.6 з підтримкою GPU PyTorch
  • scottgal/mostlylucid-nmt:cpu - Процесор - тільки МSK2 менший відрізок
  • scottgal/mostlylucid-nmt:gpu-min - Minimalne побудова графічного процессора , без попереднього завантаження моделей МSK2GBM SK3
  • scottgal/mostlylucid-nmt:cpu-min - Minimalний розвиток процесора ~1.5GBM SK2

Головні характеристики:

  • Швидшування GPU: МSK1x швидший переклад за допомогою CUDA
  • Модель Авто-Получить: завантажує моделі перекладу на demand
  • Поддержка Fallback: Випробовує Opus-MT → mBARTM SK3 МSK4 MMST5MMSC6 для максимального мовного поширення
  • Утримка звуку: Моделі таємниць через контейнер знову починають працювати
  • Здоров 'я: /health і /ready для оркестрів
  • Архітектура: запускається на x86_64 і ARMM SK2 (Apple SiliconMSC4 Raspberry PiМSK5

Подивіться повний проект на GitHub для прикладів Dockerfile

Multi-Architecture Builds з Docker Buildx

Сучасні додатки мають працювати на багатьох архітектурах : x86_64 M SK2AMD64) для серверів M SK4 ARMMSC5 для Raspberry Pi та Apple Silicon Macs , іноді навіть ARMМSK7 для вбудованих пристроїв МSK8

Чому архітектура має значення

# Problem: Image built on M1 Mac won't run on Linux server
docker build -t myapp:latest .  # Builds for ARM64
docker push myapp:latest
# Server tries to run it... error: "exec format error"

# Solution: Build for multiple platforms
docker buildx build --platform linux/amd64,linux/arm64 -t myapp:latest --push .

Налагодження Buildx

Докер Buildx включений до Docker Desktop. Для Linux:

# Verify buildx is available
docker buildx version

# Create a new builder instance
docker buildx create --name multiarch --driver docker-container --use

# Inspect and bootstrap the builder
docker buildx inspect --bootstrap

# List available platforms
docker buildx inspect | grep Platforms

Multi-Architecture Dockerfile

Більшість Dockerfiles працюють без змін.

# Use official multi-arch base images
FROM mcr.microsoft.com/dotnet/aspnet:9.0 AS base

# For platform-specific operations, use build arguments
ARG TARGETPLATFORM
ARG BUILDPLATFORM

RUN echo "Building on $BUILDPLATFORM for $TARGETPLATFORM"

# Install architecture-specific dependencies
RUN if [ "$TARGETPLATFORM" = "linux/arm64" ]; then \
        apt-get update && apt-get install -y some-arm64-package; \
    elif [ "$TARGETPLATFORM" = "linux/amd64" ]; then \
        apt-get update && apt-get install -y some-amd64-package; \
    fi

Збудова для декількох платформ

# Build and push for AMD64 and ARM64
docker buildx build \
  --platform linux/amd64,linux/arm64 \
  -t myregistry/myapp:latest \
  -t myregistry/myapp:1.0.0 \
  --push \
  .

# Build without pushing (loads into local Docker)
# Note: Can only load one platform at a time
docker buildx build \
  --platform linux/amd64 \
  -t myapp:latest \
  --load \
  .

# Build and export to tar files
docker buildx build \
  --platform linux/amd64,linux/arm64 \
  -t myapp:latest \
  -o type=tar,dest=./myapp.tar \
  .

Multi-Architecture with Docker Compose

На жаль, , Docker Compose не підтримує buildx ' Workarounds

Опція 1: Предідущий МSK1будувати зображення

# Build multi-arch images first
docker buildx build --platform linux/amd64,linux/arm64 -t myapp:latest --push .

# Then use in compose
services:
  web:
    image: myapp:latest  # Already built for multiple architectures

Опція 2: Створити сценарій

#!/bin/bash
# build-multiarch.sh

docker buildx build --platform linux/amd64,linux/arm64 \
  -t myregistry/web:latest \
  -f web/Dockerfile \
  --push \
  web/

docker buildx build --platform linux/amd64,linux/arm64 \
  -t myregistry/worker:latest \
  -f worker/Dockerfile \
  --push \
  worker/

docker-compose pull  # Pull the multi-arch images
docker-compose up -d

Реальний - Світовий приклад : CI МSK2 ЦД трубка

Рабочий процес GitHub Actions для архітектурних конструкцій

name: Build and Push Multi-Arch Images

on:
  push:
    branches: [ main ]
    tags: [ 'v*' ]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Set up QEMU
        uses: docker/setup-qemu-action@v3

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

      - name: Login to Docker Hub
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}

      - name: Extract metadata
        id: meta
        uses: docker/metadata-action@v5
        with:
          images: myregistry/myapp
          tags: |
            type=ref,event=branch
            type=semver,pattern={{version}}
            type=semver,pattern={{major}}.{{minor}}
            type=sha,prefix={{branch}}-

      - name: Build and push
        uses: docker/build-push-action@v5
        with:
          context: .
          platforms: linux/amd64,linux/arm64
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
          cache-from: type=registry,ref=myregistry/myapp:buildcache
          cache-to: type=registry,ref=myregistry/myapp:buildcache,mode=max

Цей робочий процес:

  • Триггери на приштовхування до головних або версійних ярликів
  • Налагодження QEMU для еmulaції між платформами
  • Збудування для AMD64 та ARMM SK1
  • Автоматично генерує ярлики (назви гілкиMSC1 семантичні версіїM SK2 SHA)
  • Використовує вказівку в реєстрі для швидших збудувань

Заawansовані схеми будування дронта: РеальнийM SK1 Світовий приклад

І більшість кислого-nmt послуга перекладу демонструє складні стратегії побудови докерів, оптимізовані для різних сценаріїв застосування. Цей проект показує, як будувати і розповсюджувати різноманітні візерунки з однієї бази коду

Збудувати матрицю стратегії змінних

Проект створює вісім різних варіантів зображення для різних випадків використання:

Метка для зображення МSK1 Архітектура МSK2 Швидкіший прискорювач Передзарядування моделей МSK4 Розмір Корабель для використання
:cpu (:latestМSK0 AMD64, ARMM SK3 ♫ Процесор ♫ ♫ МSK5 ♫ Так ♫ Моделі ♫
:cpu-min МSK0 AMD64, ARM64 M SK3 Процесор Ні МSK5 МSK6 ГБ Динамічне завантаження моделей
:gpu AMDM SK1 тільки МSK2 NVIDIA CUDA Так моделі МSK4 МSK5 МSK6 ~5 ГБ
:gpu-min AMDM SK1 тільки МSK2 NVIDIA CUDA Ні МSK4 M~4 ГБ МСК6 GPU з динамічними моделями MSК7

Чому багато варіантів?

  1. Produkція (повнийM SK1: Моделі, що були завантажені до залишки = миттєвий переклад МSK2 без холодного старту
  2. Розробка (minimalM SK1: Швидкі будування (~30s проти МSK2minM SK3 об 'єм МSK4монтовані моделі
  3. ҐПУМSK0 10-15x швидше для високогоM SK2швидше сценаріїв пропускної способности
  4. Процесор: Працює будь-де
  5. ARM64: Raspberry Pi , Apple Silicon МSK2 ARM сервери

Стратегія шарового пам 'яті

Dockerfiles використовують стратегічний порядок шарів, щоб максимизувати використання конструктора.

Стандартна структура Dockerfile

FROM python:3.12-slim

# Layer 1: System dependencies (rarely changes)
RUN apt-get update && apt-get install -y --no-install-recommends \
    git curl \
    && rm -rf /var/lib/apt/lists/*

# Layer 2: Python dependencies (changes when requirements.txt updates)
WORKDIR /app
COPY requirements-prod.txt .
RUN pip install --no-cache-dir -r requirements-prod.txt

# Layer 3: Model preloading (slowest layer, changes when model list changes)
ARG PRELOAD_LANGS="de,es,fr,it,nl,pl,pt,ru,zh,ja,ar,uk"
ARG PRELOAD_PAIRS=""
RUN python -c "from easynmt import EasyNMT; \
    import os; \
    langs = os.environ.get('PRELOAD_LANGS', '').split(','); \
    pairs = os.environ.get('PRELOAD_PAIRS', '').split(',') if os.environ.get('PRELOAD_PAIRS') else []; \
    model = EasyNMT('opus-mt'); \
    [model.translate('warmup', source_lang='en', target_lang=lang) for lang in langs if lang]; \
    [model.translate('warmup', source_lang=src, target_lang=tgt) for pair in pairs for src,tgt in [pair.split('->')] if pair]"

# Layer 4: Application code (changes frequently, rebuilds in seconds)
COPY app.py .
COPY src/ ./src/

# Runtime configuration
EXPOSE 8000
ENV PYTHONUNBUFFERED=1 \
    MODEL_CACHE_DIR=/app/models \
    WEB_CONCURRENCY=4

CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:8000", \
     "--worker-class", "uvicorn.workers.UvicornWorker", \
     "--timeout", "300", "--graceful-timeout", "5"]

Чому це замовлення має значення?

Слой МSK1 Частота перебудови МSK2 Час будування Рівень втраченості кэша мSK4
Базова зображення МSK1 Ніколи МSK2допоки не зміниться Python версіяM SK3 0s
Похибки системи МSK1 Нерідко МSK2 ~30s MSК4 МСК5 МСК6
Пайтонні падіння Іноді МSK2Aktualізації залежності МSK3 СМСК4 СМСК5s МСК6 MSК7 МСК8
Модель передзавантаження МSK1 Реально МSK2 зміни списку моделейM SK3 МSK5мин СМСК6 СМСК7 \ СМСк8
Код додатку МSK1 Кожен комміт МSK2 ~3s

Результат: Більшість збудувань завершено за МSK1 секунд, використовуючи вбудовані шари

Різниця між базовими зображеннями GPU та CPU

ЦП Dockerfile:

FROM python:3.12-slim

# CPU-optimized PyTorch (smaller, no CUDA)
RUN pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu

# CPU performance tuning
ENV OMP_NUM_THREADS=4 \
    MKL_NUM_THREADS=4 \
    EASYNMT_BATCH_SIZE=16

Dockerfile (Dockerfile.gpuM SK2

FROM nvidia/cuda:12.6.2-cudnn-runtime-ubuntu24.04

# Install Python 3.12
RUN apt-get update && apt-get install -y \
    python3.12 python3-pip \
    && rm -rf /var/lib/apt/lists/*

# CUDA-enabled PyTorch matching CUDA 12.6
RUN pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

# GPU performance tuning
ENV CUDA_VISIBLE_DEVICES=0 \
    EASYNMT_BATCH_SIZE=64 \
    EASYNMT_MODEL_ARGS='{"torch_dtype":"fp16"}' \
    MAX_INFLIGHT_TRANSLATIONS=1

# Runtime needs GPU access
# docker run --gpus all scottgal/mostlylucid-nmt:gpu

Головні відмінності:

  • База зображення: python:3.12-slim МSK0MB) проти nvidia/cuda:12.6.2-cudnn-runtime МSK0ГБ)
  • Роль PyTorch: Процесор (~140MBM SK2 проти CUDA МSK3 МSK4GB)
  • Розмір батареї: Процесор МSK1 проти ҐПУ МSK2 ( ҐПЗ ефективно обробляють більші пакети
  • Точность: Процесор МSK1 FP МSK2 проти ҐПУ = ФП М SK4 МСК5 наполовину точність зберігає пам 'ять ҐPU М СК6

Оптимізації ARM64

Dockerfile.arm64 включає ARM-конкретне налаштуванняM SK1

FROM python:3.11-slim-bookworm  # Debian Bookworm has better ARM support

# Minimal dependencies (ARM devices often storage-constrained)
RUN apt-get update && apt-get install -y --no-install-recommends \
    gcc g++ git curl \
    && rm -rf /var/lib/apt/lists/*

# ARM performance tuning (Raspberry Pi 4/5 with 4GB RAM)
ENV OMP_NUM_THREADS=3 \
    MKL_NUM_THREADS=3 \
    OPENBLAS_NUM_THREADS=3 \
    EASYNMT_BATCH_SIZE=4 \
    MAX_CACHED_MODELS=1 \
    MEMORY_CRITICAL_THRESHOLD=70.0

# Single worker (memory constrained)
CMD ["gunicorn", "app:app", "-w", "1", \
     "--bind", "0.0.0.0:8000", \
     "--timeout", "300"]

ARM-конкретні оптимізаціїM SK1

  1. Сниження потокуМSK0 3 нитки МSK2vs 4 на xM SK4 для термічного дротування
  2. Менші партіїМSK0 4 проти МSK2 на xM SK3 ♫ ♫ ( ♫ обмежена RAM ♫
  3. Одинокий працівник: Захищає SOOM на пристроях 4GB
  4. Мониторинг пам 'яті: Agгресивна чистка при використанні RAM
  5. Консервативні перерви: ARM пристрої повільніші , дозволять більше часу

Minimalні варіанти: Завантаження модельного циклу

Dockerfile.min підхід:

FROM python:3.12-slim

# Dependencies only, NO model preloading
COPY requirements-prod.txt .
RUN pip install --no-cache-dir -r requirements-prod.txt

# Application code
COPY app.py .
COPY src/ ./src/

# Models loaded on-demand from volume
ENV MODEL_CACHE_DIR=/models

VOLUME ["/models"]

Використовування з наmountом звуку:

# Create persistent model cache
docker volume create translation-models

# First run: downloads models on-demand
docker run -d \
  -v translation-models:/models \
  -p 8888:8000 \
  scottgal/mostlylucid-nmt:cpu-min

# Subsequent runs: reuse cached models
# Same volume mount, instant startup

Minimal у порівнянні з повною торгівлею-оффиM SK1

Аспект МSK1 Полне зображення МSK2 Minimalне зображення
Розмір зображення МSK0 2.5 ГБ МSK2 1.5 ГБ
Час будування МSK0 5-10 хвилини МSK2 30 секунд мSK4
Перший старт Моментальний переклад МSK1 1-2 завантажити макет МSK3
Наступні запуски миттєвий МSK1 митливий МSK2 якщо обсяг залишається
Використовування диска МSK0 2.5ГБ на контейнер МSK2 1.5 ГБ мSK4 спільний об 'єм мSK5
Розробка Повільне повторення МSK1 швидке повторення
Produkція Немає залежності від мережі Потрібна тривалість об 'єму МSK2

Автоматичний скрипт для створення багатовимірного-Variant

збудувати-всеM SK1sh будує всі варіанти з послідовною версією:

#!/bin/bash

# Generate version tags
VERSION=$(date +%Y%m%d.%H%M%S)
GIT_SHA=$(git rev-parse --short HEAD)

# Enable buildx for multi-platform
docker buildx create --use --name multiarch 2>/dev/null || true

echo "Building all variants for mostlylucid-nmt:${VERSION}"

# CPU Full (multi-platform)
docker buildx build \
  --platform linux/amd64,linux/arm64 \
  -f Dockerfile \
  -t scottgal/mostlylucid-nmt:cpu \
  -t scottgal/mostlylucid-nmt:latest \
  -t scottgal/mostlylucid-nmt:${VERSION} \
  --build-arg VERSION=${VERSION} \
  --build-arg VCS_REF=${GIT_SHA} \
  --push \
  .

# CPU Minimal (multi-platform)
docker buildx build \
  --platform linux/amd64,linux/arm64 \
  -f Dockerfile.min \
  -t scottgal/mostlylucid-nmt:cpu-min \
  -t scottgal/mostlylucid-nmt:${VERSION}-min \
  --build-arg VERSION=${VERSION} \
  --push \
  .

# GPU Full (AMD64 only)
docker build \
  -f Dockerfile.gpu \
  -t scottgal/mostlylucid-nmt:gpu \
  -t scottgal/mostlylucid-nmt:${VERSION}-gpu \
  --build-arg VERSION=${VERSION} \
  --build-arg PRELOAD_LANGS="de,es,fr,it,nl,pl,pt,ru,zh,ja,ar,uk" \
  --push \
  .

# GPU Minimal (AMD64 only)
docker build \
  -f Dockerfile.gpu.min \
  -t scottgal/mostlylucid-nmt:gpu-min \
  --push \
  .

echo "All builds complete!"
echo "Images tagged with version: ${VERSION}"

Прибутки від автоматизації будівлі:

  1. Сpójна версії: Тайм-тамп + Гіт SHA для відстеження
  2. Мультиплатформа: Едині командні будинки для AMD
  3. Паралельно видаwanie: Усі варіанти одночасно
  4. Гибке попереднє завантаження: Збудувати контроль args, які моделі включати
  5. CI/CD готовий: можна активувати за допомогою GitHub Actions

Практичні сценарії використання

сценарій 1: розвиток МSK1 швидке повторення )

# Use minimal image with volume mount
docker run -d \
  -v ./models:/models \
  -v ./src:/app/src \
  -p 8888:8000 \
  scottgal/mostlylucid-nmt:cpu-min

# Edit code locally, container picks up changes
# Models cached in volume, no re-download

сценарій 2: Процесор виробництва (визначаюча доступність МSK2

# Use full image, no volume needed
docker run -d \
  --restart always \
  --memory=2g \
  --cpus=2 \
  -p 8888:8000 \
  scottgal/mostlylucid-nmt:cpu

# Models preloaded, instant translation
# No external dependencies

сценарій 3: Produc GPU (high throughputM SK2

# docker-compose.yml
services:
  translation:
    image: scottgal/mostlylucid-nmt:gpu
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    environment:
      - CUDA_VISIBLE_DEVICES=0
      - EASYNMT_BATCH_SIZE=64

сценарій 4: ARMM SK1 розгортання на крайі (Raspberry Pi)

# Automatic platform selection
docker run -d \
  --restart always \
  --memory=3g \
  -p 8888:8000 \
  scottgal/mostlylucid-nmt:cpu

# Docker pulls ARM64 variant automatically
# Optimized for ARM performance

Ключові уроки з заawansованих моделей будування

  1. Кашування шарів є вирішальним: Заказ Dockerfile інструкцій по зміні частоти
  2. Збудувати варіанти, які відповідають різним потребам: Produkція проти розвитку проти обмеженого обладнання
  3. Мультиплатформа: Використовуйте buildx для AMD64 + ARMM SK3 з одного Dockerfile
  4. Передзавантаження проти завантаження на час запуску: Час побудови товару на час запуску
  5. Архітектура- конкретна оптимізація: Рухування в один бік , розміри пакетів МSK2 обмеження пам 'яті на одну платформу
  6. Автоматизація: Скрипти гарантують послідовність між варіантами
  7. Версію все: Замітки на часі + Git SHA для відстеження
  8. Стратегія обсягу: Persistent cache volumes save regeneration time

Ці шаблони з переважної кислоти-nmt демонструють виробництво - готові практики докеру, стосовані до будь-якого складного застосування з багатьма сценариями розгортанняM SK2

.NET 9 Поліпшення контейнерів

.NET 9 запропонує значні покращення у підтримці контейнерів МSK2, що зробить його легшим, ніж будь-коли раніше, щоб об 'єднати контейнери для МSK3NET програм, навіть не пишучи Dockerfile

Збудовано- в Container Publishing

За допомогою .NET 9, ви можете безпосередньо опублікувати контейнеризовану програму

# Publish as a container image (no Dockerfile needed!)
dotnet publish --os linux --arch x64 -p:PublishProfile=DefaultContainer

# Specify image name and tag
dotnet publish \
  --os linux \
  --arch x64 \
  -p:PublishProfile=DefaultContainer \
  -p:ContainerImageName=myapp \
  -p:ContainerImageTag=1.0.0

# Multi-architecture
dotnet publish --os linux --arch arm64 -p:PublishProfile=DefaultContainer

Konfiguration Properties Container

до вашого .csproj:

<Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework>net9.0</TargetFramework>

    <!-- Container Configuration -->
    <ContainerImageName>myapp</ContainerImageName>
    <ContainerImageTag>$(Version)</ContainerImageTag>
    <ContainerRegistry>myregistry.azurecr.io</ContainerRegistry>

    <!-- Base image (defaults to mcr.microsoft.com/dotnet/aspnet:9.0) -->
    <ContainerBaseImage>mcr.microsoft.com/dotnet/aspnet:9.0-alpine</ContainerBaseImage>

    <!-- Container runtime configuration -->
    <ContainerWorkingDirectory>/app</ContainerWorkingDirectory>
    <ContainerPort>8080</ContainerPort>
    <ContainerEnvironmentVariable Include="ASPNETCORE_ENVIRONMENT">Production</ContainerEnvironmentVariable>

    <!-- User (security best practice) -->
    <ContainerUser>app</ContainerUser>

    <!-- Labels -->
    <ContainerLabel Include="org.opencontainers.image.description">My awesome app</ContainerLabel>
    <ContainerLabel Include="org.opencontainers.image.source">https://github.com/me/myapp</ContainerLabel>
  </PropertyGroup>
</Project>

Тоді опублікуйте:

dotnet publish -p:PublishProfile=DefaultContainer

Привілеї збудованого-владної системи контейнерів

  1. Немає Dockerfile: Снижує складність
  2. Оптимовані зображення: Microsoft підлаштовує зображення для виконання
  3. Скорінна: Стандартні зображення у всіх .NET програмах
  4. Безпека: Автоматізовані обновлення базового зображення
  5. Маліші зображення: Obsługа підключення та компіляції AOT

Тримування і AOT для менших світлин

<PropertyGroup>
  <!-- Enable trimming to remove unused code -->
  <PublishTrimmed>true</PublishTrimmed>
  <TrimMode>full</TrimMode>

  <!-- OR use Native AOT for even smaller, faster images -->
  <PublishAot>true</PublishAot>
</PropertyGroup>

Результати:

  • СтандартМSK0 ~220MB
  • З стисканнямМSK0 ~110MB
  • З AOT: МSK1MB для простих програм

Порівняйте Dockerfile з Built-in

Традиційний підхід до Dockerfile:

FROM mcr.microsoft.com/dotnet/sdk:9.0 AS build
WORKDIR /src
COPY ["MyApp.csproj", "."]
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o /app/publish

FROM mcr.microsoft.com/dotnet/aspnet:9.0
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "MyApp.dll"]

Побудована-в контейнерному підході

# Just this!
dotnet publish -p:PublishProfile=DefaultContainer

Обидві системи створюють подібні зображення, але вбудований підхід є простішим і підтримованим.

Коли використовувати Dockerfile проти Built-in

Використовуйте Dockerfile, коли:

  • Потрібно повністю контролювати зображення
  • Встановлення системних залежності
  • Комплексні багатоповерхові будинки
  • Неstandardні базові зображення

Використовуйте вбудовані-in, колиM SK1

  • Стандартні .NET web/консольні додатки
  • Ви хочете простоти
  • Майкрософт оптимізує
  • швидке створення прототипу

Чиселовані зображення Ubuntu

.NET МSK1 підтримує "chiseled" зображення Ubuntu МSK4 ultraM SK5minimalні базові зображення

<PropertyGroup>
  <ContainerBaseImage>mcr.microsoft.com/dotnet/aspnet:9.0-noble-chiseled</ContainerBaseImage>
</PropertyGroup>

Прибутки:

  • Невеликий: МSK1 менш, ніж звичайні зображення
  • Безпека: Minimalна поверхня атаки МSK1без менеджера пакетів МSK2 схель )
  • Найшвидше: Швидший тяг і запуск

Торгівля

  • Немає ядра (важче розладуватиM SK1
  • Ограничені системи

Чудово для виробництва, де безпечність та розмір найважливіші.

Вprowadzenie до .NET Aspire

.NET Aspire - це обізнаний , хмара МSK2 готовий стег для створення розповсюдених програм M SK3 Думайте про нього як про Докер Комп 'ютер на стероидах , спеціально розроблений для MSC5 NET мікросервисів Mska6

Що таке Aspire?

Aspire надає:

  1. Оркестрування: Запуск і підключення кількох послуг локально
  2. Викриття сервісу: Услуги знаходять один одного автоматично
  3. Телеметрія: Сконструйований МSK1 в журналі МSK2 метрики , відображання
  4. Компоненти: ПредідущийM SK1конфигуровані інтеграції (Redis, PostgreSQLMSC4 RabbitMQMST5 і т.д.
  5. Розгортання: генерувати Kubernetes/Docker Compose manifests

Архітектура Aspire

Решение Aspire має три типи проектів:

  1. Гость додатку: Оркеструє ваші послуги
  2. Проекти послуг: Ваші справжні послуги
  3. За замовчанням: Спільна конфігурація

Найкращий приклад

1. Створити проект Aspire

dotnet new aspire-starter -n MyDistributedApp
cd MyDistributedApp

2. Администратор додатку Моєрозділюванеприложение МSK2Апхост МSK3Програма \ .cs \ МSK5

var builder = DistributedApplication.CreateBuilder(args);

// Add Redis cache
var cache = builder.AddRedis("cache");

// Add PostgreSQL database
var db = builder.AddPostgres("postgres")
               .AddDatabase("mydb");

// Add API service (references cache and db)
var api = builder.AddProject<Projects.MyApi>("api")
                 .WithReference(cache)
                 .WithReference(db);

// Add frontend (references API)
builder.AddProject<Projects.MyWeb>("web")
       .WithReference(api);

builder.Build().Run();

3. Використовуйте у вашій роботіM SK1

// MyApi/Program.cs
var builder = WebApplication.CreateBuilder(args);

// Aspire automatically configures these based on AppHost
builder.AddServiceDefaults();
builder.AddRedisClient("cache");
builder.AddNpgsqlDbContext<MyDbContext>("mydb");

var app = builder.Build();
app.MapDefaultEndpoints();  // Health, metrics, etc.

4. Прокрутить всеM SK1

dotnet run --project MyDistributedApp.AppHost

Старт Aspire:

  • Дашборд на http://localhost:15888
  • Усі послуги з правильною конфігурацією
  • Redis і PostgreSQL у контейнерах
  • Розповсюджене відстеження по всіх службах

Aspire vs Docker Compose

Докер Compose:

  • Язик-agnostic
  • Інфраструктура
  • Ручне відкриття сервісу
  • Візьміть свою можливість спостереження

Aspire:

  • .NETM SK1конкретні
  • Развитие
  • Автоматичне відкриття послуг
  • Вбудована телеметрія
  • генерує manifestи розгортання

Використовуйте обидві: прагнення до локального розвитку , генерує комп 'ютерний комп' ютер Docker Compose МSK2 Kuberneти для виробництва .

Розгортання aplikacji Aspire

Створити manifestи розгортання:

# Generate Docker Compose
dotnet run --project MyDistributedApp.AppHost -- \
  --publisher compose \
  --output-path ../deploy

# Generate Kubernetes manifests
dotnet run --project MyDistributedApp.AppHost -- \
  --publisher manifest \
  --output-path ../deploy/k8s

Тоді застосуйте

# Docker Compose
docker-compose -f deploy/docker-compose.yml up -d

# Kubernetes
kubectl apply -f deploy/k8s/

Komponenти Aspire

До-вибудовані інтеграції роблять додавати послуги банальнимиM SK1

// Add various backing services
var redis = builder.AddRedis("cache");
var postgres = builder.AddPostgres("db").AddDatabase("mydb");
var rabbitmq = builder.AddRabbitMQ("messaging");
var mongodb = builder.AddMongoDB("mongo").AddDatabase("docs");
var sql = builder.AddSqlServer("sql").AddDatabase("business");

// Add Azure services
var storage = builder.AddAzureStorage("storage");
var cosmos = builder.AddAzureCosmosDB("cosmos");
var servicebus = builder.AddAzureServiceBus("messaging");

// Use in services
builder.AddProject<Projects.MyService>("service")
       .WithReference(redis)
       .WithReference(postgres)
       .WithReference(rabbitmq);

Самотність МСК0 Хостинг на обмежених ресурсах МSK1 Практична оптимізація

Для запуску стека повної наслідковості, подібного до цього, необхідні значні ресурси. Якщо ви' самі-, то маєтеVPS зGB RAM або старою комп 'ютерною комп' ютерною системою 4, то тут є практичні стратегії, щоб зменшити використання ресурсів, водночас підтримуючи функцію.

Лише розвитку

Для локального розвитку, ви не потребуєте devdeps-docker-composeM SK2yml підход працює лише так, як вам потрібно:

services:
  smtp4dev:
    image: rnwood/smtp4dev
    ports:
      - "3002:80"
      - "2525:25"
    volumes:
      - e:/smtp4dev-data:/smtp4dev
    restart: always

  postgres:
    image: postgres:16-alpine
    container_name: postgres
    ports:
      - "5432:5432"
    env_file:
      - .env
    volumes:
      - e:/data:/var/lib/postgresql/data
    restart: always

Чому це працює для розвитку:

  • SMTP4Dev: Випробувати функцію електронної пошти без реального SMTP сервера
  • ПостгрSQL: Добігає до бази даних виробництва
  • Кількість відбитків: ~200 Мб оперативної пам 'яті проти МSK2 ГБ для повного стека

Подивіться повний інструктор з розвитком для інструкцій з налаштування.

Ресурс-Встановлення обмеженого виробництва

Для бюджетної системи VPS (2-4ГБ оперативної пам 'яті ), пріоритетувати основні послуги МSK2

services:
  # Core application
  mostlylucid:
    image: scottgal/mostlylucid:latest
    restart: always
    env_file: .env
    volumes:
      - ./markdown:/app/markdown
      - ./logs:/app/logs
    networks:
      - app_network
    deploy:
      resources:
        limits:
          memory: 512M
          cpus: '1.0'
        reservations:
          memory: 256M

  # Database only
  db:
    image: postgres:16-alpine
    env_file: .env
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - app_network
    deploy:
      resources:
        limits:
          memory: 512M
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER}"]
      interval: 30s
      timeout: 5s
      retries: 3

  # Caddy for HTTPS
  caddy:
    image: caddy:latest
    ports:
      - 80:80
      - 443:443
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile
      - caddy_data:/data
    networks:
      - app_network
    deploy:
      resources:
        limits:
          memory: 128M

volumes:
  db_data:
  caddy_data:

networks:
  app_network:

Що видалено і які альтернативи?

  • Ні Prometheus/Grafana: Використовуйте зовнішній контроль (UptimeRobotM SK2 BetterStack free tier)
  • Без Seq: Використовуйте файлM SK1залежне завантаження + docker logs, або Seq Cloud безкоштовний рівень
  • Ніхто не бачить вежі: Рухові aktualiзації з повідомленнями GitHub Actions
  • Ніяких послуг перекладу: Запуск на МSK1заказ у окремому контейнері, який ви запускаєте
  • Ресурсні обмеження: Захищати будь-який єдиний сервіс від використання всієї пам 'яті

Прогресивна стратегія

Почати з мінімального, додавати послуги, як потрібноM SK1

Стадія 1: Кора МSK1 МБ -1 ГБ ВПС МSK3

# Just app + database + reverse proxy
docker-compose up -d mostlylucid db caddy

Стадія 2: Додайте обсервабельність (2GB VPSM SK2

# Add lightweight monitoring
docker-compose up -d mostlylucid db caddy seq
# Use Seq free 10GB/month

Стадія 3: Полна партія МSK1 ГБ + ВПС МSK3

# Add everything
docker-compose up -d

Технології оптимізації ресурсів

1. Використовуйте альпійські зображення

services:
  myapp:
    image: postgres:16-alpine     # 50% smaller than postgres:16
    # vs
    image: postgres:16            # Full Debian base

Заощадження: Альпійські зображення менші 50-70%

2. Об 'єднана база даних

Замість однієї бази даних на службу, використовувати одну instanцію PostgreSQL з багатьма базами даних:

db:
  image: postgres:16-alpine
  # One instance, multiple databases
  # Umami, Mostlylucid, etc. all share this PostgreSQL

Заощадження: 400 Мб оперативної пам 'яті на одну додаткову базу даних, яку ви згуртуєте

3. Limit CPU for Background Services

easynmt:
  deploy:
    resources:
      limits:
        cpus: "2.0"      # Don't let translation consume all CPU
      reservations:
        cpus: "0.5"      # Guarantee minimum

Це запобігає голоду веб-приложений на фонових роботах.

4. Неперервні об 'єми кэша

Як описано в Створити зображення з дротом, montage cache directories prevents unnecessary reprocessing

mostlylucid:
  volumes:
    - /mnt/imagecache:/app/wwwroot/cache  # ImageSharp cache persists across restarts

Чому це важливо?: Без цього , кожен поновний запуск контейнеру регенерує всі зображення

5. Використовуйте внешні послуги

Услуги Самотужки МSK2 Администрований RAM МSK3 Внутрішня альтернатива M
МSK0 Скв МSK2 Мб Сек Хмара мSK4 ГБ M/місячно безкоштовна МСК6 МСК7
Прометеус МSK1 Графана МSK3 МБ ♫ ♫ МSK4 ♫ Графана Хлоуд ♫ ( ♫ вільний рівень ♫
Умамі МSK1 МSK2 МБ МСК3 Винятково СМСК4 платна СМСК5 або сама МСК6 відвідувачка в іншому місці MSК7

Стратегія: Обсервабельність відряду на безкоштовних рівнях , зберігати базову програму на вашому VPS

6. НаM SK1Сервиси на замовлення

Для непотрібних послуг, таких як переклад:

# Create a separate compose file
# translation-compose.yml
services:
  easynmt:
    image: easynmt/api:2.0.2-cpu
    ports:
      - "8888:8888"
    volumes:
      - /mnt/easynmt:/cache/

# Only run when needed
docker-compose -f translation-compose.yml up -d

# Translate your content
# ...

# Shut down when done
docker-compose -f translation-compose.yml down

Заощадження: 1-2 ГБ оперативної пам 'яті, коли служба перекладу не працює

Реальність-World Budget Hosting Example

Ось що працює на $6/місячному Hetzner VPS

# Minimal production compose
services:
  mostlylucid:
    image: scottgal/mostlylucid:latest
    restart: always
    env_file: .env
    volumes:
      - /mnt/markdown:/app/markdown
      - /mnt/logs:/app/logs
      - /mnt/imagecache:/app/wwwroot/cache
    depends_on:
      - db

  db:
    image: postgres:16-alpine
    env_file: .env
    volumes:
      - /mnt/postgres:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready"]
      interval: 30s

  cloudflared:
    image: cloudflare/cloudflared:latest
    command: tunnel run --token ${CLOUDFLARED_TOKEN}
    restart: always

  watchtower:
    image: containrrr/watchtower
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      WATCHTOWER_CLEANUP: "true"
      WATCHTOWER_LABEL_ENABLE: "true"
    command: --interval 3600  # Check once per hour, not every 5 minutes

Кількість використання ресурсів:

  • RAM: M SK1MB (повільно МSK3ГБ вільного)
  • Диск: M SK1ГБ
  • Процесор : МSK1 в стані тиші МSK2 <50% під навантаженням

Яка різниця?

  • Немає Prometheus/Grafana M SK1используйте UptimeRobot + Cloudflare Analytics)
  • Ні Seq (use docker logs + випадковий схваленняM SK1
  • Ні Умамі ( використати Cloudflare Web Analytics МSK1 безкоштовноM SK2
  • Вежба перевіряється щогодично замість кожного 5 хвилин
  • Ніяких послуг перекладу (гортати вручну, коли необхідноM SK1

Наслідування бюджету

Без Prometheus/Grafana, використовуйте ці безкоштовні альтернативи

Охрана здоров 'я:

# Simple health check script
#!/bin/bash
while true; do
  curl -f http://localhost/healthz || echo "Health check failed!" | mail -s "Alert" [email protected]
  sleep 300
done

Мониторинг журналу:

# Watch for errors
docker-compose logs -f --tail=100 | grep -i error

# Email on critical errors
docker-compose logs -f | grep -i "critical" | while read line; do
  echo "$line" | mail -s "Critical Error" [email protected]
done

використання ресурсів:

# Quick resource check
docker stats --no-stream

# Pretty output
docker stats --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}"

Версия Aspire: .NET Way

Тепер дозвольте ' переосмислити весь стек, використовуючи .NET AspireM SK2 Це дає вам всі переваги оркестрування з кращою МSK3NET інтеграцією і дивовижним досвідом програмування

Налагодження прагнення до найяскравіших

Перше, створити Гость додатку Aspire:

# Add Aspire to your solution
dotnet new aspire-apphost -n Mostlylucid.AppHost
cd Mostlylucid.AppHost

Найяскравіший варіант:

var builder = DistributedApplication.CreateBuilder(args);

// PostgreSQL with persistent data
var postgres = builder.AddPostgres("postgres")
    .WithDataVolume()  // Persistent storage
    .WithPgAdmin();     // Optional: PgAdmin for database management

var mostlylucidDb = postgres.AddDatabase("mostlylucid");
var umamiDb = postgres.AddDatabase("umami");

// Seq for centralized logging
var seq = builder.AddSeq("seq")
    .WithDataVolume();

// Redis for caching (if needed)
var redis = builder.AddRedis("cache")
    .WithDataVolume()
    .WithRedisCommander();  // Optional: Redis Commander UI

// Main blog application
var mostlylucid = builder.AddProject<Projects.Mostlylucid>("web")
    .WithReference(mostlylucidDb)
    .WithReference(seq)
    .WithReference(redis)
    .WithEnvironment("TranslateService__Enabled", "false")  // Disable for dev
    .WithHttpsEndpoint(port: 7240, name: "https");

// Umami analytics
var umami = builder.AddContainer("umami", "ghcr.io/umami-software/umami", "postgresql-latest")
    .WithReference(umamiDb)
    .WithEnvironment("DATABASE_TYPE", "postgresql")
    .WithEnvironment("TRACKER_SCRIPT_NAME", "getinfo")
    .WithEnvironment("API_COLLECT_ENDPOINT", "all")
    .WithHttpEndpoint(port: 3000, name: "http");

// Translation service (CPU version, with resource limits)
var translation = builder.AddContainer("easynmt", "easynmt/api", "2.0.2-cpu")
    .WithDataVolume("/cache")
    .WithHttpEndpoint(port: 8888, name: "http")
    .WithEnvironment("MODEL_FAMILY", "opus-mt");

// Scheduler service (Hangfire background jobs)
var scheduler = builder.AddProject<Projects.Mostlylucid_SchedulerService>("scheduler")
    .WithReference(mostlylucidDb)
    .WithReference(seq);

// Prometheus for metrics
var prometheus = builder.AddContainer("prometheus", "prom/prometheus", "latest")
    .WithDataVolume()
    .WithBindMount("./prometheus.yml", "/etc/prometheus/prometheus.yml")
    .WithHttpEndpoint(port: 9090);

// Grafana for visualization
var grafana = builder.AddContainer("grafana", "grafana/grafana", "latest")
    .WithDataVolume()
    .WithHttpEndpoint(port: 3001)
    .WithEnvironment("GF_SECURITY_ADMIN_PASSWORD", builder.Configuration["Grafana:AdminPassword"] ?? "admin");

builder.Build().Run();

По замовчуванню сервісу Aspire

Створити Найяскравіший.Defaults проект:

// Extensions.cs
public static class Extensions
{
    public static IHostApplicationBuilder AddServiceDefaults(this IHostApplicationBuilder builder)
    {
        // OpenTelemetry
        builder.Services.AddOpenTelemetry()
            .WithMetrics(metrics =>
            {
                metrics.AddAspNetCoreInstrumentation()
                    .AddHttpClientInstrumentation()
                    .AddRuntimeInstrumentation();
            })
            .WithTracing(tracing =>
            {
                if (builder.Environment.IsDevelopment())
                {
                    tracing.SetSampler(new AlwaysOnSampler());
                }

                tracing.AddAspNetCoreInstrumentation()
                    .AddHttpClientInstrumentation()
                    .AddEntityFrameworkCoreInstrumentation();
            });

        // Health checks
        builder.Services.AddHealthChecks()
            .AddCheck("self", () => HealthCheckResult.Healthy(), tags: new[] { "live" });

        return builder;
    }

    public static IApplicationBuilder MapDefaultEndpoints(this WebApplication app)
    {
        app.MapHealthChecks("/healthz");
        app.MapHealthChecks("/ready", new HealthCheckOptions
        {
            Predicate = check => check.Tags.Contains("ready")
        });

        return app;
    }
}

Обновлюйте найяскравіший/Program.cs

var builder = WebApplication.CreateBuilder(args);

// Add Aspire service defaults (telemetry, health checks)
builder.AddServiceDefaults();

// Add services
builder.AddNpgsqlDbContext<MostlylucidDbContext>("mostlylucid");
builder.AddRedisClient("cache");

// Existing service registrations...
// builder.Services.AddControllersWithViews();
// etc...

var app = builder.Build();

// Map Aspire default endpoints
app.MapDefaultEndpoints();

// Existing middleware...
app.Run();

Преподобання Aspire Approach

Дослідження розвитку:

  1. Одинакова команда: dotnet run --project Mostlylucid.AppHost все починається
  2. Дошка для вібрацій: Красивий інтерфейс на http
    • Всі послуги з живим статусом
    • Записи з усіх сервісів в одному місці
    • Розповсюдині сліди по всіх службах
    • Метрії та перевірки здоров 'я
  3. Викриття сервісу: Услуги знаходять один одного автоматично через імена
  4. Konfiguracja: Центрізований в AppHost, більше .env жонглювання

Розгортання виробництва:

Створити manifestи розгортання з Aspire:

# Generate Docker Compose
dotnet run --project Mostlylucid.AppHost -- \
  --publisher compose \
  --output-path ./deploy

# This creates a production-ready docker-compose.yml
cd deploy
docker-compose up -d

Згенерований докер-композиціяM SK1yml ( спрощенеM SK1

services:
  postgres:
    image: postgres:16
    environment:
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - postgres-data:/var/lib/postgresql/data

  mostlylucid-db:
    image: postgres:16
    # Database initialization

  seq:
    image: datalust/seq:latest
    environment:
      ACCEPT_EULA: Y
    volumes:
      - seq-data:/data

  web:
    image: scottgal/mostlylucid:latest
    environment:
      ConnectionStrings__mostlylucid: Host=postgres;Database=mostlylucid;Username=postgres;Password=${POSTGRES_PASSWORD}
      ConnectionStrings__cache: cache:6379
    depends_on:
      - postgres
      - cache
      - seq

  cache:
    image: redis:7-alpine
    volumes:
      - redis-data:/data

  # ... other services

Aspire проти традиційного комп 'ютера Docker

Funkція МSK1 Докер комп 'ютера Compose МSK2 . NET Aspire
Налагодження Ручний YAML МSK1 CM SK2 код з IntelliSense
Викриття сервісу Ручна нав 'язка МSK1 Автоматична МSK2
Обсервабельність Візьміть власний МSK1 Збудований МSK2 в ( Відкрита телеметрія
Розробка docker-compose up dotnet run + Навігатор МSK1
Розладнання Прикріпити до контейнера МSK1 FM SK2 у візуальному студії
Логи docker logs Центральна панель управления МSK1
Послідування Установка вручну
Produkція Використовуйте YAML напряму генеруйте manifests МSK2
Викладання Curve синтаксис YAML

Коли використовувати Aspire проти Docker Compose

Використовуйте Aspire, коли:

  • Будівля .NET мікросервиси
  • Ви хочете інтегрованого виправлення
  • Команда почувається комфортно з C#
  • Вам потрібно розповсюджене відстеження
  • Ви' застосовуєте додатки Azure Container Apps (нативна підтримкаM SK2

Використовуйте Docker Compose, коли:

  • Услуги поліглота (Node.jsMSC2 PythonM SK3 GoMST4 і т.д.
  • Команда надає перевагу інфраструктурі
  • Розгортання на будь-якому комп 'ютері Docker-
  • Вам потрібно максимально контролювати конфігурацію контейнерів
  • Прості одинарні-служби

Використовуйте обидва:

  • прагнути локального розвитку
  • Створити комп 'ютер Docker Compose для розробки виробництва
  • Найкращий з обох світів!

Еволюція цього блогу' Установлення дронта

Цей блог's Докерна подорож показує типовий прогресM SK1

  1. Іюль 2024 МSK1 Простій старт: Це лише додаток , CloudflaredM SK2 і Watchtower
  2. Август 2024 - Dev Dependencies: Додатковий розвиток -ніжні послуги
  3. Август 2024 МSK1 Обновлення зображення: Відкрили права на пам 'ятку для шифрування
  4. Ноябрь 2024 МSK1 Полна партія: Полна можливість спостереження за Prometheus , Grafana МSK2 Seq
  5. Сьогодні: Опція Aspire для .NET-первого розвитку

Усвідомлені уроки:

  • Почнемо з простого, додайте складність тільки тоді, коли це потрібно
  • Відокремлені конфігурації dev та виробництва
  • Ограничення ресурсів не дають можливості вбивати інших
  • Монтування звуку для кэшів заощаджує значний час переробки
  • Навігація включає нуль-зарядний час автоM SK1Aktualізації
  • Наслідковість варте вартості ресурсів в процесі виробництва

Підсумок найкращих практик

Найкращі практики Dockerfile

  1. Використовуйте багатострокові будинки
  2. Працювати як не пользователь root-
  3. Заказ інструкцій для оптимального кэшування
  4. Використовуйте конкретні базові значки для зображення (не latest)
  5. Включити контроль здоров 'я
  6. Використовувати .dockerignore щоб уникнути непотрібних файлів
  7. Минімізувати шари (з 'єднати команди RUNM SK1
  8. Використовуйте аргументи збудування для гнучкості

Докер складає найкращі практики

  1. Використовувати названі томи для даних
  2. Втілити медичні перевірки
  3. Використовувати .env для секретів (ніколи не заповнюватиM SK1
  4. Визначати конкретні мережі
  5. Використовувати depends_on з здоров 'ям
  6. Установити правила повторного запуску
  7. Відокремлені конфігурації dev/prod
  8. Ресурсні обмеження в галузі виробництва

Найкращі практики безпеки

  1. Працювати як не пользователь root-
  2. Використовуйте маліші базові зображення: chiseled/
  3. Сканувати зображення для нестабільності
  4. Обновлювати базові зображення
  5. Don' не вміщує таємниць у зображеннях
  6. Використовуйте read- тільки файлові системи, якщо це можливо
  7. Ограничення можливостей контейнерів
  8. Використовувати секрети Докера або зовнішніх секретних менеджерів

Найкращі практики в галузі ефективності

  1. Використовуйте BuildKit для швидших збудувань
  2. Кэшування шарів ліверації
  3. Multi- збудовує сцену, щоб зменшити розмір зображення
  4. Використовувати .dockerignore з великодушністю
  5. Alpine/викращені зображення для меншого розміру
  6. Використовувати встановлення звуку для розробки
  7. Konfigurувати відповідних обмежень ресурсів
  8. Використовуйте перевірки здоров 'я для оркестрування

Полегшення поширених проблем

Контейнер Won't Start

# Check logs
docker logs container-name

# Common issues:
# 1. Port already in use
docker ps | grep 8080  # Find conflicting container
docker stop conflicting-container

# 2. Missing environment variables
docker inspect container-name | grep Env

# 3. Failed health check
docker inspect container-name | grep Health -A 20

Повільні будинки

# Enable BuildKit for faster builds
export DOCKER_BUILDKIT=1

# Use build cache
docker build --cache-from myapp:latest -t myapp:latest .

# Check what's taking time
docker build --progress=plain -t myapp:latest .

Проблеми з мережею

# Containers can't communicate
# Solution: Ensure they're on the same network
docker network ls
docker network inspect network-name

# DNS not working
# Container names are DNS names within Docker networks
docker exec web ping db  # Should work if both on same network

Проблеми з дозволенням к tomu

# Permission denied on volume
# Solution: Match user IDs
FROM ubuntu
RUN useradd -u 1000 appuser  # Match host user ID
USER appuser

Завершення

Докер перетворився з простого інструменту контейнеризації на комплексну платформу для будівництва, транспортування , і запуску сучасних програм МSK2 Цей інструктор привів вас від фундаментальних складів до виробництва

Key Takeaways

Для początkujących:

Для себе , МСК0 Працівники з бюджетної системи VPS, ":".

  • Почнемо з мінімального: додаток M SK1 база даних + зворотній прокси МSK3 Мб оперативної пам 'яті
  • Використовувати альпійські зображення та обмеження ресурсів
  • Обсервабельність відряду до вільного рівня (Seq CloudM SK1 Grafana Cloud , UptimeRobot)
  • Використовувати дорогі послуги (перетворення, MLM SK2 тільки на МSK3заказ
  • $6/місячна VPS може вести блог про виробництво з вільною кімнатою

Для виробництва:

  • Здоров 'яві перевірки umożliwiają нульові-поновлення в часі відходу з телевізійною ветрою
  • Невід 'ємні мережі гарантують безпеку ( фронтальний / ізоляції зворотнього M SK2
  • Закріплення для даних, які вам потрібні для резервного копування/access
  • Наименовані томи для Docker-владної зберігання
  • CPU/ліміти пам 'яті запобігають голоду ресурсів
  • Вулка Cloudflare eliminує потребу у публічних IP-адресах

Для .NET Developers:

  • Вбудована-в контейнері для публікації в .NET 9 eliminує Dockerfiles для простих програм
  • Чиселовані зображення Ubuntu забезпечують мінімальну поверхню атаки
  • .NET Aspire пропонує найкращий досвід локального розвитку в klasiі МSK1в МSK2
  • Aspire може генерувати Docker Compose для виробництва
  • Інтеграція OpenTelemetry є безкоштовною з Aspire

Для складних випадків використання:

  • Контейнери GPU umożliwiają роботу ML/AI з швидкістю M SK1x
  • Архітектура Multi- створює підтримку ARM64 та AMDM SK2 з одного джерела
  • GitHub Actions автоматизує багатоплатформні будинки
  • Лаyer caching драматично пришвидшує повторювані будинки

Подорож

Цей блог' еволюція дронта відображає типовий прогрес:

Стадія МSK1 Услуги МSK2 Використовування оперативної пам 'яті Сложність
Стадія 1 (липень МSK1 МSK2 додаток + тунель мSK4 ♫ ♫ МSK5 МБ ♫ ♫ Прості ♫
Стадія 2 (Ог МSK1 МSK2 + Відлежність від програмування МSK5 МБ Освободження
Стадія 3 (Ог МSK1 МSK2 ♫ ♫ МSK3 ♫ Обновлення частоти ♫ ♫
Стадія 4 (Nov МSK1 МSK2 Полна обсервабельність
Стадія 5 ( СьогодніM SK1 МSK2 + Опція Наполегливість МSK4 Варіабель Современный МSK6

Модель: Почати з простого , розв 'язати проблеми, як вони виникають M SK2 додавати складність тільки тоді, коли це потрібно .

Що' СледующаяM SK1

В залежності від вашого шляху:

  • Докер для навчання: Почнемо з Докер Compose basics
  • Самотіла-Hosting: Попробуйте мінімальне налаштування VPS з цієї статті
  • Мікросервиси для будівництва: Дослідження .NET Aspire
  • Працюючи з МЛ: Подивіться на найяскравіший-nmt переклад
  • Мультиплатформа: Установити buildx для ARM64 + AMDM SK3

Ресурс

офіційна документація:

Цей блог 's Docker Series:

  1. Докер Compose - На початку
  2. Залежність від розвитку - Постановка локального dev
  3. Створити зображення з дротом - Права на звук
  4. Цей artykuł - Глибокий подив на виробництво

Поміжні проекти:

Пам 'ятайте, що найкраща архітектура відповідає вашим потребам без непотрібної складності.

Щасливе контейнеризування! M SK1

Finding related posts...
logo

© 2026 Scott Galloway — Unlicense — All content and source code on this site is free to use, copy, modify, and sell.