# डॉकर विकास गहराई: मूल से विस्तृत करने के लिए।

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

<!--category-- Docker, .NET, DevOps, Containers -->
## परिचय

डॉकर ने बुनियादी तौर पर बदला है कि हम किस तरह निर्माण करते हैं, जहाज़ बनाते हैं, और अनुप्रयोग चलाते हैं ।

जो कुछ एक साधारण उपकरण के रूप में शुरू हुआ है वह आधुनिक अनुप्रयोग विकास और तैनाती के लिए पूर्ण पर्यावरण में विकास कर रहा है.

1. **[यह मेरे डॉकर श्रृंखला में चौथे और सबसे व्यापक लेख है।](/dockercompose)**आप डॉकer करने के लिए नया कर रहे हैं, आप के साथ प्रारंभ करना चाहते हैं:
2. **[डॉकर बनाएं](/dockercomposedevdeps)**- मूल बहुमुखी सेटअप के साथ प्रारंभ किया जा रहा है (Juky 2024)
3. **[विकास प्लगइन के साथ डॉकर निर्माण](/imagesharpwithdocker)**- स्थानीय डेव्स वातावरण विन्यास किया जा रहा है (आर्ट २०24)

छवि को डॉकर के साथ कम्पाइल करें

- **- अनुमति मुद्दों को हल करना (आतुस २०24)**इस गहरी गति में, हम उन नींव पर निर्माण करेंगे की जांच करने के लिए:
- **उत्पाद- बार डॉकर बनाएं**: इस ब्लॉग का वास्तविक ढेर चल रहा है
- **सीमित संसाधनों पर स्वयं**: बजट बनाने के लिए व्यावहारिक तकनीक
- **जीयूपी समर्थन**: कंटेनरों मेंएमएल कार्य चला रहा है
- **बहु- तत्वप्रयोगक निर्माण**: 6464 और एएम64 को समर्थन देना
- **.नेट 9 कंटेनर विशेषताएँ**: डाकफ़ाइल के बगैर अंतर्निर्मित कंटेनर प्रकाशन

> . Waypapaped

: आज के ज़माने में रेडियो स्टेशन के पास जाना

[TOC]

## ध्यान दीजिए: यह एआई / एक तरीका है जिस पर मेरे परीक्षण किए जाते हैं ।

### मैंने इसे काग़ज़ों की एक बेल भरी है, मेरी समझ, सवाल मैं इस लेख तैयार करने के लिए किया था.

यह मजेदार है और मैं कहीं और नहीं भरा एक अंतर भर देता है.

क्या आप एक सरल वेब एप ए या रेडियो-बाइट के साथ एक जटिल सूक्ष्म रचना की निगरानी कर रहे हैं जीयूपीपी-पिड मशीन सीखने वाले मॉडलों के साथ, यह गाइड आपको डॉकर से ले जाता है जो कि आमतौर पर चल रहे अनुप्रयोगों के साथ।

- **शास्त्रियों का मानना है: समझ - बूझ से काम लेना**डॉकर वास्तव में, क्या है?
- **इसके कोर में, डॉकर एक कंटेनर है जो आपके अनुप्रयोग को प्रभावित करता है और इसकी सभी निर्भरता को एक कंटेनर में रखता है.**बाहरी मशीनों से भिन्‍न, जो पूरी ऑपरेटिंग सिस्टम को नष्ट कर देती हैं, होस्ट ओएस कर्नेल को अलग - अलग उपयोगकर्ता अंतरिक्ष बनाए रखने के दौरान बाँटती हैं ।

### ज़रा सोचिए:

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

# The container solution
"Ship your machine!" 
```

आभासी मशीन्स

1. **: प्रत्येक VM एक पूरा ओएस स्टैक चलाता है (लिन कर्नेल, तंत्र लाइब्रेरी, आदि)**समाहित कर्ता
2. **: होस्ट कर्नेल, पैकेज सिर्फ अनुप्रयोग कोड तथा निर्भरता को छोटा तथा तेज**डेवलपर के लिए कंटेनर क्यों ज़रूरी हैं
3. **समाहित अंशों ने अनेक गंभीर समस्याओं को हल किया:**वातावरण संगतता
4. **विकास, जाँच तथा उत्पादन वातावरण एक जैसे हैं**डिपेंडेंसीिंग
5. **: अब न तो "नरक" और न ही परस्पर विरोध लाइब्रेरी संस्करण**रिप्रोप्लेम बिल्ड्स

### : समान इनपुट = एक ही आउटपुट, प्रत्येक बार

#### तेज गति

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

**: अलग- अलग- अलग कंटेनर, न कि मिनट में**संसाधन ई- मेल

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

: एक ही होस्ट पर दर्जनों बर्तन चलाएँ

- **ज़रूरी डॉकर्स**छवियों को समाहित करता है
- **छवियाँ**चालू नहीं किया जा सका, परत सिस्टम्स.
- **डॉकर फ़ाइल में प्रत्येक निर्देश नई परत बनाता है:**यह परत शक्तिशाली है:

#### कैशिंग

: बदला नहीं जा सकता परतों को फिर से प्रयोग किया जाता है, गति को बढ़ा - चढ़ाकर तैयार किया जाता है**साझा कर रहा है**

: बहुत से छवियों को बेस परतों में साझा कर सकते हैं

```
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. **डॉकनेवाला डी. डी.**डॉकer प्रारंभ करने में गड़बड़ी का एक आम स्रोत:`COPY`एक डॉकerफ़ाइल में आदेश आपके मशीन पर नहीं चलता है - वे निर्माण कंटेनर ओएस के अंदर चला जाता है.`ADD`यहाँ वास्तव में क्या होता है:
2. **ऐसा क्यों:**मुख्य अंतर्दृष्टि:`RUN`स्थानीय फ़ाइल- सिस्टम
3. **: आपका**और
4. **आपके मशीन से पढ़ा जा रहा है**छवि बिल्ड करें

: आपका`apt-get`कंटेनर ओएस में चलाया जा रहा है (अपनी मशीन नहीं)

**आउटपुट छवि**

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

: निर्माण के दौरान बनाई गई सभी परतों में

#### क्रास- क्रास

: आप विंडोज़ पर हो सकते हैं, लिनक्स सिस्टम कमांड के प्रयोग से

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

#### इसीलिए आप लिख सकते हैं

एक डॉकer फ़ाइल में कमांड विंडो पर - वे विंडोज़ पर नहीं चल रहे हैं!

```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. **उदाहरण गड़बड़ी का दृश्‍य:**डॉकर डेमन आपके स्थानीय फ़ाइल सिस्टम के बीच अनुवाद को संभालता है तथा आंतरिक निर्माण वातावरण को संभालता है.
2. **डॉकefile सर्वोत्तम अभ्यास**यहाँ एक उत्पादन तैयार है।`.csproj`फूल को समझना
3. **यहाँ वास्तव में क्या होता है एक बहु- मंच डॉकर निर्माण के दौरान - जहां फ़ाइलें आती हैं और जहां वे समाप्त होती हैं:**इस प्रवाह की कुंजी अन्तर्दृष्टि:`npm run build`केडीएम छवि छोड़ दिया गया
4. **: 1.GB एस डीकेन को प्रकाशित करने के बाद हटाया जाता है, जो कि आउटपुट को आगे बढ़ा रहा है**: `appsettings.json`परत कंचा डाउनलोड किया जा रहा है`wwwroot/`: नक़ल किया जा रहा है
5. **स्रोत कोड का मतलब है कि वितरण प्राप्त किया जाना चाहिए जब तक कि निर्भरता परिवर्तन नहीं हो जाता**फ्रन्टएण्ड संपत्ति
6. **: अलग से (बहुत कम के द्वारा)**) और पिछली छवि में कॉपी की

**कॉन्फ़िगरेशन फ़ाइलें**

1. **और**आपके मशीन से सामग्री नक़ल की गयी है, नहीं बनाया गया
2. **अंतिम छवि**: कम से कम स्थिति छवि (0-22MBMB) प्रारंभ करता है + आपका एपलमेंट (0-230MBMB) + गुण (2.05MB) = 0. 255MB कुल
3. **सिर्फ उत्पादन फ़ाइलें**: स्रोत कोड, obj/ sh/, नोड_BAR_के लिए यह अंतिम छवि में कभी नहीं बना सकते
4. **मुख्य सिद्धांत सचित्रित करते हैं:**बहु- स्टेज निर्माण
5. **: अलग-अलग निर्माण/plkowest चरण अंतिम छवि आकार को नाटकीय रूप से कम करता है**परत अनुकूलन

#### : स्रोत कोड के लिए बेहतर CTATH के लिए फ़ाइलों की नक़ल करें

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

## सुरक्षा

: नॉन- ग्रे- उपयोक्ता के रूप में चलाएँ

### स्वास्थ्य जाँच

: मास्टरटरी अनुप्रयोग स्वास्थ्य को मॉनीटर कर सकते हैं

- एनवायरनमेंट (E)
- : उत्पादन डिफ़ॉल्ट सेट करें
- निर्माण और चल रहा है
- डॉकर बनाएं: मल्टी- के- कम्पेरेशन
- डॉकर बनाएं आपको बहु- सरकशी अनुप्रयोगों को पारिभाषित करने तथा चलाने देता है.

कंटेनरों का पालन करने के बजाय, आप अपने पूरे अनुप्रयोग का वर्णन YAएमएल फ़ाइल में करते हैं.`docker run`डॉकर ने क्यों लिखा?

### एक आम वेब अनुप्रयोग पर गौर कीजिए:

एनईएस. वेनेस्ट वेब ए**एसक्यूएल डाटाबेस`docker-compose.yml`**रेडिस कैश

```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/*`यहाँ है
3. **वास्तविक उत्पादन**जो इस साइट को चलाता है (सबसे कम अनियंत्रित.com):
4. **कुंजी उत्पाद पैटर्न:**एकल संजाल
5. **: सभी सेवाओं पर**आसान के लिए
6. **बिन्ड माउन्ट्स**: होस्ट पथ (H)
7. **आग्रहित डाटा के लिए आप बैकअप/CONK की जरूरत है**नामित आवाज़`.env`: डॉकer-mand भंडार डाटा के लिए आप सीधे पहुँच की आवश्यकता नहीं है

### प्रहरीदुर्ग लेबल्स

#### स्वचालित अद्यतन के लिए सिर्फ अद्यतन सेवाएँ नियत की जा रही हैं.

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

संसाधन सीमा`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
```

: 5432 के बजाय 5266 पर एसक्यूएल पर जाएँ ताकि अन्य अवसरों के साथ परस्पर विरोध से बच सके

#### वातावरण फ़ाइलें

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

**: गुप्त में**:

- फ़ाइल (कभी git) को बन्द नहीं किया गया है
- डॉकर कुंजी विशेषताएँ
- सेवा डिपेंडेंसीज़
- डॉकर रेडियो स्टेशन प्रारंभ अनुक्रम.

**वह**:

- वेब ए प्रारंभ करने से पहले डाटाबेस स्वास्थ्य जाँच की आवश्यकता है.
- वातावरण चर तथा रहस्य
- उत्पादन रहस्य के लिए, डॉकनर या बाहरी गुप्त प्रबंधक (AWSCHIs प्रबंधक, AWESCK, Alicap, Hicrapap, प्रयोग करें.

#### नामित आवाज़ vs vd माउन्ट्स

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

services:
  web:
    networks:
      - frontend
      - backend

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

नामित आवाज़

#### डॉकर द्वारा प्रबंधित किया गया

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

कंटेनर के अंदर का डाटा फिर से प्रारंभ करें

- डॉकर कमांड के साथ बैक अप/ अप किया जा सकता है
- क्रास- कम्पेबिलिटीGenericName
- बिन्ड माउन्ट्स

### होस्ट फ़ाइल सिस्टम में सीधे नज़रअंदाज़ करें

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

### विकास के लिए उपयोगी (लिंग कोड फिर से लोड किया जा रहा है)

कॉन्फ़िगरेशन फाइल, लॉग, अपलोड किया जा रहा है

**नेटवर्किंग**नेटवर्क अकेलेपन प्रदान करते हैं.

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

**यहाँ, डाटाबेस सिर्फ बैकेंड सेवाओं के लिए पहुँच योग्य है, सीधे रूप से प्रकट नहीं है.**स्वास्थ्य जाँच

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

**स्वास्थ्य जाँच डॉकर को स्वीकारें:**निर्धारित करता है कि क्या कंटेनर वास्तव में तैयार है (सिर्फ प्रारंभ नहीं)

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

## कन्टेनमेंट फिर से चालू करें

रेडियो स्टेशनों की स्थिति दें (केर्करर, डॉक पिम)

### सामान्य डॉकर बनाएं कमांड

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

### बहुत से लिखना फ़ाइलें अलग करता है:

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

### प्लगिन- क़िस्म.yml

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

### (मूल:

प्लगिन- क़िस्म.ov.pml[(स्टिट्शन - स्वचालित):](https://github.com/scottgal/mostlylucid-nmt)डाक- क़िस्म.profiles.yml

(अनुप्रयोग):

- **कोकून में सीपी समर्थन: एमएल कार्य को सक्षम सक्षम करता है**मशीन सीखने, वैज्ञानिक गणक, और वीडियो प्रक्रिया अनुप्रयोगों के लिए अकसर जीपीयू त्वरण की ज़रूरत होती है.
- **निलिलिया के समाहित क्षेत्र के माध्यम से डॉ.**NVIIEA कंटेनर सेट किया जा रहा है
- **GUP- apele पायथन/PK अनुप्रयोग के लिए डॉक फ़ाइल**GPS कंटेनर चलाया जा रहा है
- **डॉकर में जीपीएस**वास्तविक विश्‍व उदाहरण: जीपीयू तथा सीपीयू बिल्ड के साथ अनुवाद सेवा

#### यहाँ से एक असली उत्पादन उदाहरण है

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

#### अधिकतर- nmd- tud

मैं एक तंत्रिका मशीन अनुवाद सेवा मैं इस ब्लॉग पर शक्ति स्वचालित संग्रह का निर्माण किया।

```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`जीपीयू तथा सीपीयू भिन्नताएँ
- `scottgal/mostlylucid-nmt:cpu`- एक ही कोड मूल से, भिन्न आधार छवियों
- `scottgal/mostlylucid-nmt:gpu-min`बहु- तत्वप्रयोगक निर्माण
- `scottgal/mostlylucid-nmt:cpu-min`- समर्थन एएम64 और 6464

**अनुकूलित डॉकर छवि**

- **- पूरा और कम से कम किस्मों के**उत्पादीय- प्रसंग
- **- स्वास्थ्य जाँच, मात्रा लगन, सही लॉगिंग**जीयूपी- कैप्टी अनुवाद सेवा
- **सीपीयू- सिर्फ वैकल्पिक**जीपीएस के बगैर एनवायरनमेंटों के लिए, वही सेवा सीपीयू पर चलती है:
- **उपलब्ध छवि चर:**- CUUN 12.6 पिकाय जी समर्थन के साथ (उदाहरण के लिए 0. 53GB)
- **- सिर्फ सीपीयू, छोटा फुट प्रिंट ( सर्वोत्तम 0. 53GB)**: `/health`- न्यूनतम जीपीयू बिल्ड, कोई पूर्व मॉडल लोड नहीं (उदाहरण4GB)`/ready`- न्यूनतम सीपीयू बिल्ड (0.5GB)
- **कुंजी फीचर:**GPSA त्वरण

: 10-15x तेजी से अनुवाद कोएडी के साथ[मॉडल स्वचलित डाउनलोड](https://github.com/scottgal/mostlylucid-nmt): अनुवाद मॉडलों पर डाउनलोड करें

## फालबैक समर्थन

: अधिकतम भाषा विस्तार के लिए ओका-एम- एम- एमई350 एम2एम100 प्रयास करता है

### आवाज बढ़ाएँ

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

### : टोकरी के पार कैश मॉडल फिर से चालू करें

स्वास्थ्य अंत - बिन्दु

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

### और

भाई - बहनों के लिए

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

### मल्टी- ऑर्चिचकcolor

```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 \
  .
```

### : x86_64 और ARM64 पर चलाएँ (कस्टिकॉन, रासेम्परी पी)

देखें

**पूरा प्रोजेक्ट इंब्सबे में पूरा प्रोजेक्ट**

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

**डॉकफ़ाइल उदाहरणों के लिए, स्क्रिप्ट और एपीआई दस्तावेज़.**

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

### मल्टी- axxx

आधुनिक अनुप्रयोगों को अनेक संरचनाओं पर चलाने की ज़रूरत है: x86_64 (AMD664) सर्वरों के लिए, रेफ़ॉम्परी पी और एप्सिलिकॉन मेकज़ के लिए, कभी कभी - कभी डिफ़ॉल्ट उपकरणों के लिए भी ।

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

क्यों बहु- अवसर पदार्थ

- बिल्डएक्स विन्यास किया जा रहा है
- डॉकर बिल्डर को डॉकर डेस्कटॉप में शामिल किया गया है.
- लिनक्स के लिए:
- मल्टी- axxxx डॉकer फ़ाइल
- ज़्यादातर डॉकर फ़ाइलें बिना परिवर्तन किए काम करती हैं, लेकिन यहाँ कुछ सुझाव हैं:

## बहुत से प्लेटफ़ॉर्मों के लिए निर्माण

डॉकर के साथ बहु- स्थिर

### दुर्भाग्य से, डॉकर बनाएं सीधे ही बिल्डक्स का समर्थन नहीं करता.

कार्य- विकल्प:

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

### विकल्प 1: पूर्व- निर्माण छवियों

विकल्प 2: बिल्ड स्क्रिप्ट`.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. automatically configures these based on AppHost
builder.AddServiceDefaults();
builder.AddRedisClient("cache");
builder.AddNpgsqlDbContext<MyDbContext>("mydb");

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

**वास्तविक वैश्विक उदाहरण: CI/सीडी पाइप लाइन**

```bash
dotnet run --project MyDistributedApp.AppHost
```

GiHHWOON कार्य बहुप्रयोगीय निर्माण के लिए प्रवाहित करता है:

- यह कार्य प्रवाह:
- ट्रिगर पर मुख्य या संस्करण टैग
- क्रास- स्कवेयरपाइंट के लिए क्यूईएमयू सेट करता है
- AMDM64 और ARM64 के लिए निर्माण

### टैग स्वचलित तैयार करता है (बोचक नाम, एनसेप्टिक संस्करण, SHA)

**तीव्र ताज़ा करने के लिए रजिस्ट्री कैशिंग इस्तेमाल करता है**

- .ENT 9 घटकर सुधरता है
- .NT 9 बरतन समर्थन के लिए महत्वपूर्ण सुधार प्रस्तुत करता है, जिससे पहले से ही बर्तन को सीधे रखना आसान हो जाता है.
- अंतर्निर्मित कंटेनर प्रकाशन
- 9 के साथ, आप सीधे एक कंटेनर अनुप्रयोग को प्रकाशित कर सकते हैं:

**समाहित सामग्री गुण कॉन्फ़िगर किया जा रहा है**

- अपने में जोड़ें
- 4.
- सब कुछ चलाएँ:
- स्क्वर्ट:
- http://own-host: 15888

**उचित कॉन्फ़िगरेशन के साथ सभी सेवाएँ**थॉरिस तथा क्लैम्प्स मेंcolor- kcm- sets. kgm

### सेवा के दौरान अलग - अलग तरह के प्रचारक

एपीरे वी- डॉकर निर्माण

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

### भाषा- नेडिस्किक

इन्फास्ट्रक्चर्ड

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

## मैनुअल सेवा खोज

अपनी खुद ब्लॉयरता लाने के लिए

### एसपीप:

विशिष्ट[विकास- प्रभाव](/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
```

**अंतर्निर्मित टिक- इनप्शन**

- **तैनातिंग प्रदर्शन बनाता है**दोनों का उपयोग करें
- **: स्थानीय विकास के लिए अप्रचलक, निर्माण के लिए डॉकर/केर बनाता है.**डी. एन.
- **तैनातिंग प्रदर्शन उत्पन्न करें:**फिर तैनाती:

एसपीय घटक[परियोजनाओं को जोड़ने के लिए अलग रखे जाने वाले विकल्प:](/dockercomposedevdeps)सीमित संसाधनों पर स्व-शोषण: व्यावहारिक विज्ञापन

### ऊपर दिए गए व्यक्‍ति की तरह पूर्ण ब्लिटमेंट चलाना महत्त्वपूर्ण साधन की माँग करता है ।

यदि आप 4GB रैम या एक पुराने लैपटॉप के साथ एक VPOP पर खुद को समर्पित कर रहे हैं, तो यहाँ संसाधनों के उपभोग को कम करने के लिए व्यावहारिक योजनाएँ हैं...

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

**सिर्फ विकास डिपेंडेंसीज़**

- **स्थानीय विकास के लिए, आपको पूरा उत्पादन ढेर की आवश्यकता नहीं है.**वह
- **ईएसपीएस- बैक- क़िस्म.yml**बस इतना कि तुम्हें किस चीज़ की ज़रूरत है`docker logs`क्यों यह विकास के लिए कार्य करता है:
- **एसएमटीपी4डीव**एक वास्तविक एसएमटीपी सर्वर के बिना ईमेल कार्यशीलता जांचता है.
- **एसक्यूएल**: मेल से उत्पादन डाटाबेस
- **कुल फुट- छपाई**: ~200MB रैम बनाम 2-4GB पूरे ढेर के लिए

### देखें

पूर्ण विकास निर्भरता मार्गदर्शन

**निर्देश सेटअप करने के लिए.**

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

**संसाधन- कंटेनेंस उत्पाद सेटअप**

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

**बजट vP (- 4GB रैम) के लिए आवश्यक सेवाओं से पहले:**

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

### क्या हटाया गया है और विकल्प:

#### कोई प्रोग्रेस/जीना नहीं

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

**: बाहरी निगरानी का प्रयोग करें (ऊपरबीबीो, बेहतर क़िस्म का कवर फ्री- रैपर)**सेमी नहीं

#### : फ़ाइल- आधारित लॉगिंग + इस्तेमाल करें

, या सेक बादल फ्री- रैपर

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

**प्रहरीदुर्ग**: GiH Hब क्रियाएँ सूचना के साथ मैनुअल अद्यतन करें

#### कोई अनुवाद सेवा नहीं

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

: अलग कंटेनर में चलाएँ जिसे आप दस्ती रूप से शुरू करते/ मिटते हैं

#### संसाधन सीमा

सभी स्मृति प्रयोग से किसी भी सेवा को रोकें[प्रगतिशील संवर्द्धन कौशल](/imagesharpwithdocker)कम से कम, आवश्यकता के रूप में जोड़ें सेवाएँ प्रारंभ करें:

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

**चरण 1: कोर (512MB-1GB VPS)**चरण 2: ऑब्सर्वीमेंट (GB वीएस) जोड़ें

#### चरण 3: पूरा स्टैक (4GB+ डबल्यूपी)

संसाधन एवरमाइजेशन टेक्स
|---------|-----------------|---------------------|
1 ..
आगामी छवियों का प्रयोग करें
सहेज रहे हैं

**यू. एस.**2

#### साझा डाटाबेस उदाहरण

एक डाटाबेस के प्रति सेवा के बजाय, बहुत से डाटाबेस के साथ एक एसक्यूएल इंस्टैंस प्रयोग करें:

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

**सहेज रहे हैं**: 400MB रैम प्रति अतिरिक्त डेटाबेस आप उन्‍नत

### 3

पृष्ठभूमि सेवा हेतु सीपीयू सीमा

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

**यह आपके वेब अनुप्रयोग को भूख से पृष्ठभूमि कार्य को रोकता है.**

- 4.
- कैश आवाज़ कम करें
- जो छा रहा था

**छवि को डॉकर के साथ कम्पाइल करें**

- , कैश निर्देशिका को चालू करने से अनावश्यक पुनः चालू नहीं हो रहा है:
- यह क्यों ज़रूरी है`docker logs`: इसके बिना, प्रत्येक कंटेनर फिर से प्रारंभ करें सभी लघुछवियों/ प्रोसेस्ड छवियों को.
- 5.
- बाहरी सेवा उपयोग करें (फ्री टीयर)
- बताओ सेवा शून्य से भरी हुई रैम

### ( 10GB/ माह का सफर खाली)

उन्हीं बातों से पता चलता है कि परमेश्‍वर के वचन का अध्ययन करने से ही हम पर गहरा असर होता है ।

**उन्हीं दिनों के बारे में कुछ नहीं कहा जा सकता.**

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

**: sliderscrercers को बंद करके, कोर अनुप्रयोग को अपने वीपीएस पर रखें.**

```bash
# Quick resource check
docker stats --no-stream

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

## 6.

ऑन- डेविल सेवाएँ

### कभी - कभी अनुवाद की तरह इस्तेमाल की जानेवाली सेवाओं के लिए:

सहेज रहे हैं

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

**: 1- 2GB रैम जब अनुवाद सेवा चल नहीं रहा है**

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

### वास्तविक विश्वव्यापी बजट युक्त उदाहरण

यहां क्या एक $6/ माहवारी हेट्‌स वीपीयू, 4GB रैम पर दौड़ता है:**कुल संसाधन उपयोग:**रैम: ~ 800MB (बाता 3.2GB मुक्त)

```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;
    }
}
```

### डिस्क: ~2GB

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

### सीपीयू: <10%, <50% लोड होने के बाद

**क्या अलग है:**

1. **कोई प्रोग्रेस/ ग्रेफ्नाना नहीं (मानसिकस + बादलीय)**: `dotnet run --project Mostlylucid.AppHost`सेमी (यूपी) नहीं (m)
2. **+ कभी- कभी gpp)**कोई उममी नहीं (जब बादल भरे हुए जाल का इस्तेमाल नहीं किया जाता)
   - प्रहरीदुर्ग हर 5 मिनट के बजाय घंटे की जाँच करती है
   - कोई अनुवाद सेवा नहीं (जब आवश्यक हो तो दस्ती रूप से चलाएँ)
   - बजट पर मॉनीटर
   - प्रोग्रेस/जीफ्ना, ये मुफ़्त विकल्प इस्तेमाल करते हैं:
3. **स्वास्थ्य निगरानी:**लॉग निगरानी:
4. **संसाधन उपयोग:**एसपीरा संस्करण:`.env`अब चलो पूरे ढेर का उपयोग करते हैं.

**यह आपको बेहतर बनाने और एक अद्‌भुत डेवलपर का अनुभव करने में मदद देता है ।**

अति सुन्दरी के लिए अप सेट करना

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

**प्रथम, एसपीपीएपी ए होस्ट तैयार करें:**लगभग सांडित. APHHo/P.c:

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

### एसपीम सेवा तयशुदा

बनाएँ
|---------|---------------|-------------|
| **ज़्यादातर लोगों का मानना है कि यह सब - के - सब खत्म हो गया है ।**परियोजना:
| **सर्वाधिक अल्पपारदर्शिता/ प्रोग्राम अद्यतन करें**हाज़िर होने के फायदे
| **विकास अनुभव:**एकल कमांड
| **सभी प्रारंभ करें** | `docker-compose up` | `dotnet run`डैश बोर्ड
| **: सुंदर यूआई http://obonhost: 15888 शो:**जीने की स्थिति के साथ सभी सेवाएँ
| **सभी सेवाओं से एक जगह में लॉग करता है** | `docker logs`सेवाओं के पार चिह्नित निशान
| **मेट्रिक्स तथा स्वास्थ्य जाँच**सेवा खोज
| **सेवाएँ नाम के जरिए एक दूसरे को स्वचालित प्राप्त होती हैं**कॉन्फ़िगरेशन
| **: एएचटी में मध्यीकृत, कोई और नहीं**मार - पीट

### उत्पादन सहायक:

**एसपीपीटर से अज़ाबर प्रकट करें:**

- डॉकer- डिज़ाइन तैयार किया गया है.yml
- (चिल्लाता):
- एपीरेल पारंपरिक डॉकर बनाएं
- फ्लॉरल डॉकर लिखा .
- सेटअप

**Gdk मैनुअल YAएमएल C# कोड के साथ इंस्टिलेटिकसन के साथ**

- सेवा खोज
- Libisofs मैनुअल एनवीएस स्वचालित
- ऑब्सर्वेटरी
- सेंटीमीटर अपना स्वयं का रॉक-इन्डर ले आओ (Oelloz) Name
- विकास

**+ डिशबोर्डक्ला**

- डिबगिंग
- मासिक स्टूडियो में जोड़ें (_t)
- लॉग

### लिथुए हुए तूफान- ठहरा हुआ तूफान

ट्रैस कर रहा है

1. **[Libisofs सेटअप को स्वचालित रूप से वितरित किया जा रहा है Global Catalog](/dockercompose)**उत्पाद
2. **[Libisofs का प्रयोग सीधे क्लिक करें](/dockercomposedevdeps)**वक्र को समझ रहा है
3. **[INBGAC सिंटेक्स C# आप पहले से ही जानते हैं](/imagesharpwithdocker)**अपिड डॉकर बनाएं कब इस्तेमाल करें
4. **[जब उपयोग हो तो एसपीप इस्तेमाल करें:](/dockercompose)**. stase माइक्रोस्लेवों का निर्माण
5. **आप प्रोजेक्ट बंद करें**टीम सी# के साथ सहज है

**आपको प्राप्ति की आवश्यकता है**

- आप Amapreaks के लिए तैनात कर रहे हैं (अनुप्रयोग समर्थन)
- जब:
- पॉलीग्लाट सेवाएँ (कोई कार्य नहीं, पायथन, गो आदि.)
- टीम इन्फा- इन्फ- कोड YAएमएल में पसंद करते हैं
- किसी भी डॉकer- संगत होस्ट में ले जाया जा रहा है
- आपको संग्राहक कॉन्फ़िगरेशन पर अधिकतम नियंत्रण की आवश्यकता है

## सादा एकल- कर्मचारी तैनात

### दोनों का उपयोग करें:

1. स्थानीय विकास के लिए एपीयूटर
2. निर्माण गतिविधि के लिए डॉकर बनाया जा रहा है
3. सबसे अच्छा संसार!
4. इस ब्लॉग डॉकर सेटअप का एवोल्यूशन`latest`)
5. इस ब्लॉग के डॉकर यात्रा से स्थानीय प्रगति दिखाई देता है:
6. जुलाई 2024 - सरल प्रारंभ`.dockerignore`: सिर्फ ऐप, बादल भरे और प्रहरीदुर्ग (अँग्रेज़ी)
7. अगस्त 2024 - दवेदी
8. : जोड़ा गया विकास- सिर्फ सेवाएँ

### अगस्त 2024 - छवि सुस्पष्ट रूप से

1. क कैशिंग के लिए आवाज़ निर्धारक अनुमतियाँ हल कीं:
2. नवंबर 2024 - पूरा स्टैक
3. : प्रोक्लासस, कनानाना, सेक के साथ पूर्ण रूप से गुप्तता`.env`आज
4. : एपीप विकल्प .
5. सबक सीखा:`depends_on`सरल आरंभ करें, जब ज़रूरत पड़े केवल जटिलता जोड़ता है
6. अलग इंजिन तथा उत्पादन कॉन्फ़िगरेशन
7. संसाधन सीमा एक सेवा को अन्यों को मारने से रोक सकती है
8. कैश्स के लिए वॉल्यूम माउन्ट्स महत्वपूर्ण पुनःप्रयोगिंग समय को सहेजने के लिए

### प्रहरीदुर्ग शून्य से अधिक समय स्वचालित अद्यतन सक्षम करता है

1. उत्पादन में संसाधन लागत के लायक है
2. सर्वोत्तम अभ्यास सारांश
3. डॉकefile सर्वोत्तम अभ्यास
4. बहु- मंच बनाने के लिए इस्तेमाल करें
5. नॉन-text उपयोक्ता के रूप में चलाएँ
6. पाक कैशिंग के लिए अनुक्रम
7. विशिष्ट बेस छवि टैग इस्तेमाल करें (नहीं)
8. स्वास्थ्य जाँच शामिल करें

### प्रयोक्ता

1. अनावश्यक फ़ाइलों को हटाने के लिए
2. परतों को न्यूनतम करें (बिनेट कमांड्स)
3. पेशियों के लिए तर्क का उपयोग करें
4. डॉकर बनाएं उत्तम अभ्यास`.dockerignore`डाटा के लिए नामित वॉल्यूम का प्रयोग करें
5. स्वास्थ्य जाँच लागू करें
6. प्रयोक्ता
7. भेदों के लिए (कभी नहीं)
8. सुस्पष्ट नेटवर्क पारिभाषित करें

## प्रयोक्ता

### स्वास्थ्य स्थिति के साथ

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

### अलग dev/ prod कॉन्फ़िगरेशन

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

### उत्पादन में संसाधन सीमा

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

## सुरक्षा उत्तम अभ्यास

नॉन-text उपयोक्ता के रूप में चलाएँ

### चिंची/मिनिक बेस छवियों का प्रयोग करें

**संरक्षा के लिए स्कैन छवियों**

- बेस बिंबों को अद्यतन रखें[छवियों में रहस्य शामिल नहीं करें](/dockercompose)सिर्फ पढ़ने के लिए फ़ाइल सिस्टम इस्तेमाल करें जहाँ संभव हो
- कंटेनर क्षमताओं को सीमित करें[डॉकर रहस्य या बाहरी गुप्त प्रबंधक का प्रयोग करें](/dockercomposedevdeps)परफ़ॉर्मेंस उत्तम अभ्यास
- तेज़ गति के लिए बिल्ड करें[तीव्र परत कंचा कैशिंग](/imagesharpwithdocker)छवि आकार कम करने के लिए मल्टी- स्टेज बनाता है

**प्रयोक्ता**

- उदार
- छोटे आकार के लिए आवधिक छवि
- विकास के लिए आवाज़ माउन्ट्स इस्तेमाल करें
- उचित संसाधन सीमा कॉन्फ़िगर करें
- रेडियो पर होनेवाली स्वास्थ्य जाँच का इस्तेमाल करें

**सामान्य वाद - विवाद सहना**

- समाहित नहीं करेगा
- धीमा बिल्ड्स
- नेटवर्किंग अंक
- वॉल्यूम अनुमति अंक
- कंटेनमेंट
- डॉकर ने एक सरल कवरीकरण उपकरण से निर्माण, निगरानी, और आधुनिक अनुप्रयोग चलाने के लिए एक व्यापक मंच पर विकास किया है ।

**इस गाइड ने आपको बुनियादी जानकारी से लिया है बनाने के लिए तैयार करने के लिए तैयार करने के लिए। वास्तव में दुनिया के उदाहरणों के साथ।**

- कुंजी अगलों को दूर ले जाता है
- आरंभिक के लिए:
- इससे प्रारंभ करें
- मूल डॉकer निर्माण सेटअप
- - सिर्फ 3 सेवाओं

**प्रयोक्ता**

- विकास- सिर्फ डिपेंडेंसीज़
- स्थानीय कार्य के लिए
- सामान्य मुद्दों को हल करें
- वॉल्यूम अनुमतियाँ

### जल्दी

बजट वीपीएस पर स्व-शोधनों के लिए:

न्यूनतम: AMP + डाटाबेस + विपरीत प्रॉक्सी (0. 0800MB रैम)
|-------|----------|-----------|------------|
| **अ- निर्दिष्ट छवियों तथा संसाधन सीमा इस्तेमाल करें**फ्रीटरों के लिए बन्द करने की क्षमता (संवरिक बादल, हवा का बादल, ऊपर- टाइमो)
| **सिर्फ महँगी सेवाओं को चलाएँ (टीएसडीडी, एमएल)**$ 6/ माह वीपीएस एक ब्लॉग को अनदेखा करने के लिए चला सकते हैं
| **उत्पादों के लिए:**स्वास्थ्य जाँच प्रहरीदुर्ग के साथ शून्य- घंटे अद्यतन सक्षम करती है
| **अलग नेटवर्क सुरक्षा प्रदान करते हैं (अनुप्रयोग/बैक पृथक)**डाटा के लिए बिन माउन्ट्स जिन्हें आप बैकअप/ जानकारी की आवश्यकता है
| **डॉकएवर भंडार के लिए नामांकित आवाज़**सीपीयू/ मेमोरी सीमा संसाधन भूखा रहने से रोक सकती है

**बादल flance Tannl सार्वजनिक आईपी पता की आवश्यकता है**.नेटटी डेवलपर के लिए:

### .ENT 9 में अंतर्निर्मित कंटेनर प्रकाशन, सादा ऐक्स्स के लिए डॉकफ़ाइलों को नष्ट करता है

ऊबुन्टू की छवियाँ कम से कम हमले प्रदान करती हैं

- **. NENT Aagape स्थानीय विकास का अनुभव प्रदान करता है**निर्माण गतिविधि के लिए डॉकर बनाया जा सकता है[ओपनहेम्पर एकीकरण एपीपीर के साथ मुक्त आता है](/dockercompose)
- **विस्तृत उपयोग के लिए:**जीयूपी कंटेनर एमएल/ इतालवी कार्य को १०- १५x गति के साथ लोड करने में सक्षम करते हैं
- **बहु- स्थिर निर्माण समर्थन**GiHW क्रियाएँ स्वचालित पढ़ती हैं
- **परत को अपडेट करने में तेज़ी से प्रगति**यात्रा[इस ब्लॉग के डॉकर विकास में विशिष्ट प्रगति:](https://github.com/scottgal/mostlylucid-nmt)
- **INBS चरण स्पेस सेवा जिनकी रैम**चरण 1

### (Juky 2024) 2002- 2005 + tenlance ~300 सिंगा

**चरण 2**

- [(Aug 2024) 2006 + Devi पुनःआख़िरआख़िर  ](https://docs.docker.com/)
- [चरण 3](https://docs.docker.com/compose/compose-file/)
- [(उग 2024) 2006- 2007 + खंड फिक्सेस 0.00MBविश्‍वविद्यालय](https://github.com/dotnet/dotnet-docker)
- [चरण 4](https://learn.microsoft.com/en-us/dotnet/aspire/)
- [(कोईv 2024)lseralvivative ~. 5GB ईमानन](https://github.com/NVIDIA/nvidia-container-toolkit)
- [चरण 5](https://github.com/docker/buildx)

**( आज) बख्शिश + एसपीपीरे विकल्प बुरी तरह से संपादित करें**

1. [नमूना](/dockercompose): जब वे उठते हैं तब सरल, समस्याओं को सुलझाइए, ज़रूरत पड़ने पर केवल जटिलता को ही बढ़ाते हैं ।
2. [अगला क्या है?](/dockercomposedevdeps)और तुम इस क़दर ग़ाफ़िल हो तो ख़ुदा के आगे सजदे किया करो
3. [डॉक ले-आउट को समझ रहा है](/imagesharpwithdocker): इससे प्रारंभ करें
4. डॉकर्स मूल

**स्व- होस्टिंग**

- [: इस लेख से न्यूनतम VePS सेटअप की कोशिश करें](https://github.com/scottgal/mostlylucid-nmt)माइक्रोफ़ॉर्मेट बनाया जा रहा है
- [: . . . . . . . . . .](https://github.com/scottgal/mostlylucidweb)एमएल कार्य लोड किया जा रहा है

: जाँच करें

Happy containerizing! 🐳