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

<datetime class="hidden">2025-11-09T14:00</datetime>

<!--category-- Docker, .NET, DevOps, Containers -->
## Введение

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

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

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

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

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

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

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

[TOC]

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

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

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

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

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

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

```bash
# 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ність використання ресурсів**: Запуск десятків контейнерів на одному хосте

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

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

```bash
# 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 створює новий шар:

```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)
```

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

```dockerfile
# 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

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

```dockerfile
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

```dockerfile
# 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"]
```

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

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

```mermaid
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. **Очевидне середовище**: Установити початкові стандарти виробництва

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

```bash
# 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

```yaml
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

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

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

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

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

```bash
# .env file (never commit to git!)
DB_PASSWORD=super_secret_password
SMTP_PASSWORD=another_secret
```

```yaml
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

```yaml
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 завантаження

#### Мережа

```yaml
networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge

services:
  web:
    networks:
      - frontend
      - backend

  db:
    networks:
      - backend  # Not exposed to frontend
```

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

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

```yaml
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

```bash
# 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

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

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

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

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

```yaml
services:
  web:
    image: registry.example.com/myapp:${VERSION}
    restart: always
    deploy:
      replicas: 3
      resources:
        limits:
          cpus: '2'
          memory: 2G
```

```bash
# 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

```bash
# 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

```dockerfile
# 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

```bash
# 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
```

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

```yaml
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](https://github.com/scottgal/mostlyucid-nmt), я створив послугу перекладу нейронних машин, яка дає можливість автоматичним - перекладам на цьому блогі

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

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

#### GPU-Accelerated Translation Service

```yaml
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

```yaml
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](https://github.com/scottgal/mostlyucid-nmt/blob/main/README.md) для прикладів Dockerfile

## Multi-Architecture Builds з Docker Buildx

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

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

```bash
# 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:

```bash
# 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 працюють без змін.

```dockerfile
# 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
```

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

```bash
# 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будувати зображення**

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

# Then use in compose
```

```yaml
services:
  web:
    image: myapp:latest  # Already built for multiple architectures
```

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

```bash
#!/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 для архітектурних конструкцій

```yaml
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](https://github.com/scottgal/mostlyucid-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**

```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:**

```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**

```dockerfile
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

```dockerfile
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** підхід:

```dockerfile
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ом звуку:**

```bash
# 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** будує всі варіанти з послідовною версією:

```bash
#!/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 швидке повторення )**

```bash
# 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**

```bash
# 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**

```yaml
# 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)**

```bash
# 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, ви можете безпосередньо опублікувати контейнеризовану програму

```bash
# 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`:

```xml
<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>
```

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

```bash
dotnet publish -p:PublishProfile=DefaultContainer
```

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

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

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

```xml
<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:**

```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"]
```

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

```bash
# 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ні базові зображення

```xml
<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**

```bash
dotnet new aspire-starter -n MyDistributedApp
cd MyDistributedApp
```

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

```csharp
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**

```csharp
// 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**

```bash
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и розгортання:

```bash
# 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
```

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

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

# Kubernetes
kubectl apply -f deploy/k8s/
```

### Komponenти Aspire

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

```csharp
// 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](/dockercomposedevdeps) підход працює лише так, як вам потрібно:

```yaml
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 ГБ для повного стека

Подивіться [повний інструктор з розвитком](/dockercomposedevdeps) для інструкцій з налаштування.

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

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

```yaml
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**

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

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

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

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

```bash
# Add everything
docker-compose up -d
```

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

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

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

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

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

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

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

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

#### 3. Limit CPU for Background Services

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

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

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

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

```yaml
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Сервиси на замовлення

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

```bash
# 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

```yaml
# 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, використовуйте ці безкоштовні альтернативи

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

```bash
# Simple health check script
#!/bin/bash
while true; do
  curl -f http://localhost/healthz || echo "Health check failed!" | mail -s "Alert" you@example.com
  sleep 300
done
```

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

```bash
# 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" you@example.com
done
```

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

```bash
# 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:

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

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

```csharp
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** проект:

```csharp
// 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

```csharp
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:

```bash
# 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

```yaml
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 Простій старт](/blog/dockercompose)**: Це лише додаток , CloudflaredM SK2 і Watchtower
2. **[Август 2024 - Dev Dependencies](/blog/dockercomposedevdeps)**: Додатковий розвиток -ніжні послуги
3. **[Август 2024 МSK1 Обновлення зображення](/blog/imagesharpwithdocker)**: Відкрили права на пам 'ятку для шифрування
4. **[Ноябрь 2024 МSK1 Полна партія](/blog/usingprometheusandgrafanatomonitoraspnet)**: Полна можливість спостереження за 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

```bash
# 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
```

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

```bash
# 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 .
```

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

```bash
# 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

```bash
# 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:**

- Почнемо з [базове налаштування Docker Compose](/blog/dockercompose) - лише МSK1 послуги
- Використовувати [розвиток- тільки залежності](/blog/usingprometheusandgrafanatomonitoraspnet) для місцевої роботи
- Вигадувати звичайні проблеми, такі як [uprawnienia до звуку](/blog/imagesharpwithdocker) рано

**Для себе , МСК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](/blog/dockercompose)
- **Самотіла-Hosting**: Попробуйте мінімальне налаштування VPS з цієї статті
- **Мікросервиси для будівництва**: Дослідження .NET Aspire
- **Працюючи з МЛ**: Подивіться на [найяскравіший-nmt переклад](https://github.com/scottgal/mostlylucid-nmt)
- **Мультиплатформа**: Установити buildx для ARM64 + AMDM SK3

### Ресурс

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

- [Докерна документація](https://docs.docker.com/)
- [Докер Комп 'ютерна референція](https://docs.docker.com/compose/compose-file/)
- [.NET Контейнерні зображення](https://github.com/dotnet/dotnet-docker)
- [.NET Aspire Documentation](https://learn.microsoft.com/en-us/dotnet/aspire/)
- [Набір інструментів для контейнерів NVIDIA](https://github.com/NVIDIA/nvidia-container-toolkit)
- [Докер Buildx](https://github.com/docker/buildx)

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

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

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

- [найбільш зрозуміле-nmt](https://github.com/scottgal/mostlylucid-nmt) - GPUM SK1CPU Translation service with multi-arch builds
- [Найяскравіший джерело блогу](https://github.com/scottgal/mostlylucidweb) - Подивіться на справжній код і сконструюйте файли

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

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