Wdrażanie modeli AI za pomocą Azure Developer CLI

April 4, 2026 · View on GitHub

Nawigacja po rozdziale:

📚 Strona główna kursu: AZD dla początkujących
📖 Aktualny rozdział: Rozdział 2 - Rozwój z myślą o AI
⬅️ Poprzedni: Integracja Microsoft Foundry
➡️ Następny: Warsztaty AI
🚀 Następny rozdział: Rozdział 3: Konfiguracja

Ten przewodnik zawiera kompleksowe instrukcje dotyczące wdrażania modeli AI za pomocą szablonów AZD, obejmujące wszystko od wyboru modelu po wzorce wdrożeń produkcyjnych.

Uwaga o walidacji (2026-03-25): Przepływ pracy AZD w tym przewodniku został sprawdzony z azd w wersji 1.23.12. Dla wdrożeń AI zajmujących więcej czasu niż domyślne okno wdrożenia usługi, aktualne wydania AZD obsługują azd deploy --timeout <seconds>.

Strategia wyboru modelu

Modele Microsoft Foundry

Wybierz odpowiedni model do swojego przypadku użycia:

# azure.yaml - Model configuration
services:
  ai-service:
    project: ./infra
    host: containerapp
    config:
      AZURE_OPENAI_MODELS: |
        [
          {
            "name": "gpt-4.1-mini",
            "version": "2024-07-18",
            "deployment": "gpt-4.1-mini",
            "capacity": 10,
            "format": "OpenAI"
          },
          {
            "name": "text-embedding-3-large",
            "version": "1",
            "deployment": "text-embedding-3-large", 
            "capacity": 30,
            "format": "OpenAI"
          }
        ]

Planowanie pojemności modelu

Typ modelu	Przypadek użycia	Zalecana pojemność	Uwagi dotyczące kosztów
gpt-4.1-mini	Czat, pytania i odpowiedzi	10-50 TPM	Ekonomiczne dla większości obciążeń
gpt-4.1	Złożone wnioskowanie	20-100 TPM	Wyższy koszt, stosuj dla funkcji premium
text-embedding-3-large	Wyszukiwanie, RAG	30-120 TPM	Dobry domyślny wybór do semantycznego wyszukiwania i pobierania
Whisper	Mowa na tekst	10-50 TPM	Obciążenia przetwarzania audio

Konfiguracja AZD dla modeli AI

Konfiguracja szablonu Bicep

Twórz wdrożenia modeli za pomocą szablonów Bicep:

// infra/main.bicep
@description('OpenAI model deployments')
param openAiModelDeployments array = [
  {
    name: 'gpt-4.1-mini'
    model: {
      format: 'OpenAI'
      name: 'gpt-4.1-mini'
      version: '2024-07-18'
    }
    sku: {
      name: 'Standard'
      capacity: 10
    }
  }
  {
    name: 'text-embedding-3-large'
    model: {
      format: 'OpenAI'
      name: 'text-embedding-3-large'
      version: '1'
    }
    sku: {
      name: 'Standard'
      capacity: 30
    }
  }
]

resource openAi 'Microsoft.CognitiveServices/accounts@2023-05-01' = {
  name: openAiAccountName
  location: location
  kind: 'OpenAI'
  properties: {
    customSubDomainName: openAiAccountName
    networkAcls: {
      defaultAction: 'Allow'
    }
    publicNetworkAccess: 'Enabled'
  }
  sku: {
    name: 'S0'
  }
}

@batchSize(1)
resource deployment 'Microsoft.CognitiveServices/accounts/deployments@2023-05-01' = [for deployment in openAiModelDeployments: {
  parent: openAi
  name: deployment.name
  properties: {
    model: deployment.model
  }
  sku: deployment.sku
}]

Zmienne środowiskowe

Skonfiguruj środowisko aplikacji:

# konfiguracja .env
AZURE_OPENAI_ENDPOINT=https://your-openai-resource.openai.azure.com/
AZURE_OPENAI_API_VERSION=2024-02-15-preview
AZURE_OPENAI_CHAT_DEPLOYMENT=gpt-4.1-mini
AZURE_OPENAI_EMBED_DEPLOYMENT=text-embedding-3-large

Wzorce wdrożeń

Wzorzec 1: Wdrożenie w jednym regionie

# azure.yaml - Single region
services:
  ai-app:
    project: ./src
    host: containerapp
    config:
      AZURE_OPENAI_ENDPOINT: ${AZURE_OPENAI_ENDPOINT}
      AZURE_OPENAI_CHAT_DEPLOYMENT: gpt-4.1-mini

Najlepsze dla:

Rozwoju i testowania
Aplikacji na pojedynczym rynku
Optymalizacji kosztów

Wzorzec 2: Wdrożenie wieloregionowe

// Multi-region deployment
param regions array = ['eastus2', 'westus2', 'francecentral']

resource openAiMultiRegion 'Microsoft.CognitiveServices/accounts@2023-05-01' = [for region in regions: {
  name: '${openAiAccountName}-${region}'
  location: region
  // ... configuration
}]

Najlepsze dla:

Aplikacji globalnych
Wysokiej dostępności
Rozkładu obciążenia

Wzorzec 3: Wdrożenie hybrydowe

Połącz modele Microsoft Foundry z innymi usługami AI:

// Hybrid AI services
resource cognitiveServices 'Microsoft.CognitiveServices/accounts@2023-05-01' = {
  name: cognitiveServicesName
  location: location
  kind: 'CognitiveServices'
  properties: {
    customSubDomainName: cognitiveServicesName
  }
  sku: {
    name: 'S0'
  }
}

resource documentIntelligence 'Microsoft.CognitiveServices/accounts@2023-05-01' = {
  name: documentIntelligenceName
  location: location
  kind: 'FormRecognizer'
  properties: {
    customSubDomainName: documentIntelligenceName
  }
  sku: {
    name: 'S0'
  }
}

Zarządzanie modelem

Kontrola wersji

Śledź wersje modeli w konfiguracji AZD:

{
  "models": {
    "chat": {
      "name": "gpt-4.1-mini",
      "version": "2024-07-18",
      "fallback": "gpt-4.1"
    },
    "embedding": {
      "name": "text-embedding-3-large",
      "version": "1"
    }
  }
}

Aktualizacje modelu

Używaj hooków AZD do aktualizacji modeli:

#!/bin/bash
# hooks/predeploy.sh

echo "Checking model availability..."
az cognitiveservices account list-models \
  --name $AZURE_OPENAI_ACCOUNT_NAME \
  --resource-group $AZURE_RESOURCE_GROUP \
  --query "[?name=='gpt-4.1-mini']"

# Jeśli wdrożenie trwa dłużej niż domyślny limit czasu
azd deploy --timeout 1800

Testy A/B

Wdróż wiele wersji modelu:

param enableABTesting bool = false

resource chatDeployment 'Microsoft.CognitiveServices/accounts/deployments@2023-05-01' = {
  parent: openAi
  name: 'gpt-4.1-mini-${enableABTesting ? 'v1' : 'prod'}'
  properties: {
    model: {
      format: 'OpenAI'
      name: 'gpt-4.1-mini'
      version: '2024-07-18'
    }
  }
  sku: {
    name: 'Standard'
    capacity: enableABTesting ? 5 : 10
  }
}

Aspekty produkcyjne

Planowanie pojemności

Oblicz wymaganą pojemność na podstawie wzorców użycia:

# Przykład obliczania pojemności
def calculate_required_capacity(
    requests_per_minute: int,
    avg_prompt_tokens: int,
    avg_completion_tokens: int,
    safety_margin: float = 0.2
) -> int:
    """Calculate required TPM capacity."""
    total_tokens_per_request = avg_prompt_tokens + avg_completion_tokens
    total_tpm = requests_per_minute * total_tokens_per_request
    return int(total_tpm * (1 + safety_margin))

# Przykład użycia
required_capacity = calculate_required_capacity(
    requests_per_minute=10,
    avg_prompt_tokens=500,
    avg_completion_tokens=200,
    safety_margin=0.3
)
print(f"Required capacity: {required_capacity} TPM")

Konfiguracja autoskalowania

Skonfiguruj autoskalowanie dla aplikacji kontenerowych:

resource containerApp 'Microsoft.App/containerApps@2024-03-01' = {
  name: containerAppName
  properties: {
    template: {
      scale: {
        minReplicas: 1
        maxReplicas: 10
        rules: [
          {
            name: 'http-rule'
            http: {
              metadata: {
                concurrentRequests: '10'
              }
            }
          }
          {
            name: 'cpu-rule'
            custom: {
              type: 'cpu'
              metadata: {
                type: 'Utilization'
                value: '70'
              }
            }
          }
        ]
      }
    }
  }
}

Optymalizacja kosztów

Wprowadzaj kontrole kosztów:

@description('Enable cost management alerts')
param enableCostAlerts bool = true

resource budgetAlert 'Microsoft.Consumption/budgets@2023-05-01' = if (enableCostAlerts) {
  name: 'ai-budget-alert'
  properties: {
    timePeriod: {
      startDate: '2024-01-01'
      endDate: '2024-12-31'
    }
    timeGrain: 'Monthly'
    amount: 1000
    category: 'Cost'
    notifications: {
      Actual_GreaterThan_80_Percent: {
        enabled: true
        operator: 'GreaterThan'
        threshold: 80
        contactEmails: [
          'admin@yourcompany.com'
        ]
      }
    }
  }
}

Monitorowanie i obserwowalność

Integracja Application Insights

Skonfiguruj monitorowanie dla obciążeń AI:

resource applicationInsights 'Microsoft.Insights/components@2020-02-02' = {
  name: applicationInsightsName
  location: location
  kind: 'web'
  properties: {
    Application_Type: 'web'
    WorkspaceResourceId: logAnalyticsWorkspace.id
  }
}

// Custom metrics for AI models
resource aiMetrics 'Microsoft.Insights/components/analyticsItems@2020-02-02' = {
  parent: applicationInsights
  name: 'ai-model-metrics'
  properties: {
    content: '''
      customEvents
      | where name == "AI_Model_Request"
      | extend model = tostring(customDimensions.model)
      | extend tokens = toint(customDimensions.tokens)
      | extend latency = toint(customDimensions.latency_ms)
      | summarize 
          requests = count(),
          avg_tokens = avg(tokens),
          avg_latency = avg(latency)
        by model, bin(timestamp, 5m)
    '''
    type: 'query'
    scope: 'shared'
  }
}

Metryki niestandardowe

Śledź metryki specyficzne dla AI:

# Niestandardowa telemetria dla modeli AI
import logging
from applicationinsights import TelemetryClient

class AITelemetry:
    def __init__(self, instrumentation_key: str):
        self.client = TelemetryClient(instrumentation_key)
    
    def track_model_request(self, model: str, tokens: int, latency_ms: int, success: bool):
        """Track AI model request metrics."""
        self.client.track_event(
            'AI_Model_Request',
            {
                'model': model,
                'tokens': str(tokens),
                'latency_ms': str(latency_ms),
                'success': str(success)
            }
        )
        
    def track_model_error(self, model: str, error_type: str, error_message: str):
        """Track AI model errors."""
        self.client.track_exception(
            type=error_type,
            value=error_message,
            properties={
                'model': model,
                'component': 'ai_model'
            }
        )

Kontrole stanu zdrowia

Wdróż monitorowanie kondycji usług AI:

# Punkty końcowe do sprawdzania stanu zdrowia
from fastapi import FastAPI, HTTPException
import httpx

app = FastAPI()

@app.get("/health/ai-models")
async def check_ai_models():
    """Check AI model availability."""
    try:
        # Testuj połączenie z OpenAI
        async with httpx.AsyncClient() as client:
            response = await client.get(
                f"{AZURE_OPENAI_ENDPOINT}/openai/deployments",
                headers={"api-key": AZURE_OPENAI_API_KEY}
            )
            
        if response.status_code == 200:
            return {"status": "healthy", "models": response.json()}
        else:
            raise HTTPException(status_code=503, detail="AI models unavailable")
            
    except Exception as e:
        raise HTTPException(status_code=503, detail=f"Health check failed: {str(e)}")

Kolejne kroki

Przejrzyj Przewodnik integracji Microsoft Foundry dotyczący wzorców integracji usług
Wykonaj Warsztaty AI, aby zdobyć praktyczne doświadczenie
Wdrażaj praktyki produkcyjne AI dla rozwiązań przedsiębiorstw
Poznaj Przewodnik rozwiązywania problemów AI dotyczący typowych problemów

Zasoby

Nawigacja po rozdziale:

📚 Strona główna kursu: AZD dla początkujących
📖 Aktualny rozdział: Rozdział 2 - Rozwój z myślą o AI
⬅️ Poprzedni: Integracja Microsoft Foundry
➡️ Następny: Warsztaty AI
🚀 Następny rozdział: Rozdział 3: Konfiguracja

Zastrzeżenie:
Dokument ten został przetłumaczony za pomocą usługi tłumaczenia AI Co-op Translator. Mimo że dążymy do dokładności, prosimy pamiętać, że automatyczne tłumaczenia mogą zawierać błędy lub niedokładności. Oryginalny dokument w jego języku źródłowym powinien być uznawany za autorytatywne źródło. W przypadku informacji krytycznych zalecane jest skorzystanie z profesjonalnego tłumaczenia przez człowieka. Nie ponosimy odpowiedzialności za jakiekolwiek nieporozumienia lub błędne interpretacje wynikające z korzystania z tego tłumaczenia.