1# Preset Deployment Workflow - Detailed Implementation
2 
3This file contains the full step-by-step bash/PowerShell scripts for preset (optimal region) model deployment. Referenced from the main [SKILL.md](../SKILL.md).
4 
5---
6 
7## Phase 1: Verify Authentication
8 
9Check if user is logged into Azure CLI:
10 
11```bash
12az account show --query "{Subscription:name, User:user.name}" -o table
13```
14 
15**If not logged in:**
16```bash
17az login
18```
19 
20**Verify subscription is correct:**
21```bash
22# List all subscriptions
23az account list --query "[].[name,id,state]" -o table
24 
25# Set active subscription if needed
26az account set --subscription <subscription-id>
27```
28 
29---
30 
31## Phase 2: Get Current Project
32 
33**Check for PROJECT_RESOURCE_ID environment variable first:**
34 
35```bash
36if [ -n "$PROJECT_RESOURCE_ID" ]; then
37  echo "Using project resource ID from environment: $PROJECT_RESOURCE_ID"
38else
39  echo "PROJECT_RESOURCE_ID not set. Please provide your Azure AI Foundry project resource ID."
40  echo ""
41  echo "You can find this in:"
42  echo "  • Azure AI Foundry portal → Project → Overview → Resource ID"
43  echo "  • Format: /subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.CognitiveServices/accounts/{account}/projects/{project}"
44  echo ""
45  echo "Example: /subscriptions/abc123.../resourceGroups/rg-prod/providers/Microsoft.CognitiveServices/accounts/my-account/projects/my-project"
46  echo ""
47  read -p "Enter project resource ID: " PROJECT_RESOURCE_ID
48fi
49```
50 
51**Parse the ARM resource ID to extract components:**
52 
53```bash
54# Extract components from ARM resource ID
55# Format: /subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.CognitiveServices/accounts/{account}/projects/{project}
56 
57SUBSCRIPTION_ID=$(echo "$PROJECT_RESOURCE_ID" | sed -n 's|.*/subscriptions/\([^/]*\).*|\1|p')
58RESOURCE_GROUP=$(echo "$PROJECT_RESOURCE_ID" | sed -n 's|.*/resourceGroups/\([^/]*\).*|\1|p')
59ACCOUNT_NAME=$(echo "$PROJECT_RESOURCE_ID" | sed -n 's|.*/accounts/\([^/]*\)/projects.*|\1|p')
60PROJECT_NAME=$(echo "$PROJECT_RESOURCE_ID" | sed -n 's|.*/projects/\([^/?]*\).*|\1|p')
61 
62if [ -z "$SUBSCRIPTION_ID" ] || [ -z "$RESOURCE_GROUP" ] || [ -z "$ACCOUNT_NAME" ] || [ -z "$PROJECT_NAME" ]; then
63  echo "❌ Invalid project resource ID format"
64  echo "Expected format: /subscriptions/{sub-id}/resourceGroups/{rg}/providers/Microsoft.CognitiveServices/accounts/{account}/projects/{project}"
65  exit 1
66fi
67 
68echo "Parsed project details:"
69echo "  Subscription: $SUBSCRIPTION_ID"
70echo "  Resource Group: $RESOURCE_GROUP"
71echo "  Account: $ACCOUNT_NAME"
72echo "  Project: $PROJECT_NAME"
73```
74 
75**Verify the project exists and get its region:**
76 
77```bash
78# Set active subscription
79az account set --subscription "$SUBSCRIPTION_ID"
80 
81# Get project details to verify it exists and extract region
82PROJECT_REGION=$(az cognitiveservices account show \
83  --name "$PROJECT_NAME" \
84  --resource-group "$RESOURCE_GROUP" \
85  --query location -o tsv 2>/dev/null)
86 
87if [ -z "$PROJECT_REGION" ]; then
88  echo "❌ Project '$PROJECT_NAME' not found in resource group '$RESOURCE_GROUP'"
89  echo ""
90  echo "Please verify the resource ID is correct."
91  echo ""
92  echo "List available projects:"
93  echo "  az cognitiveservices account list --query \"[?kind=='AIProject'].{Name:name, Location:location, ResourceGroup:resourceGroup}\" -o table"
94  exit 1
95fi
96 
97echo "✓ Project found"
98echo "  Region: $PROJECT_REGION"
99```
100 
101---
102 
103## Phase 3: Get Model Name
104 
105**If model name provided as skill parameter, skip this phase.**
106 
107Ask user which model to deploy. **Fetch available models dynamically** from the account rather than using a hardcoded list:
108 
109```bash
110# List available models in the account
111az cognitiveservices account list-models \
112  --name "$PROJECT_NAME" \
113  --resource-group "$RESOURCE_GROUP" \
114  --query "[].name" -o tsv | sort -u
115```
116 
117Present the results to the user and let them choose, or enter a custom model name.
118 
119**Store model:**
120```bash
121MODEL_NAME="<selected-model>"
122```
123 
124**Get model version (latest stable):**
125```bash
126# List available models and versions in the account
127az cognitiveservices account list-models \
128  --name "$PROJECT_NAME" \
129  --resource-group "$RESOURCE_GROUP" \
130  --query "[?name=='$MODEL_NAME'].{Name:name, Version:version, Format:format}" \
131  -o table
132```
133 
134**Use latest version or let user specify:**
135```bash
136MODEL_VERSION="<version-or-latest>"
137```
138 
139**Detect model format:**
140 
141```bash
142# Get model format from model catalog (e.g., OpenAI, Anthropic, Meta-Llama, Mistral, Cohere)
143MODEL_FORMAT=$(az cognitiveservices account list-models \
144  --name "$ACCOUNT_NAME" \
145  --resource-group "$RESOURCE_GROUP" \
146  --query "[?name=='$MODEL_NAME'].format" -o tsv | head -1)
147 
148# Default to OpenAI if not found
149MODEL_FORMAT=${MODEL_FORMAT:-"OpenAI"}
150 
151echo "Model format: $MODEL_FORMAT"
152```
153 
154> 💡 **Model format determines the deployment path:**
155> - `OpenAI` — Standard CLI deployment, TPM-based capacity, RAI policies apply
156> - `Anthropic` — REST API deployment with `modelProviderData`, capacity=1, no RAI
157> - All other formats (`Meta-Llama`, `Mistral`, `Cohere`, etc.) — Standard CLI deployment, capacity=1 (MaaS), no RAI
158 
159---
160 
161## Phase 4: Check Current Region Capacity
162 
163Before checking other regions, see if the current project's region has capacity:
164 
165```bash
166# Query capacity for current region
167CAPACITY_JSON=$(az rest --method GET \
168  --url "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.CognitiveServices/locations/$PROJECT_REGION/modelCapacities?api-version=2024-10-01&modelFormat=$MODEL_FORMAT&modelName=$MODEL_NAME&modelVersion=$MODEL_VERSION")
169 
170# Extract available capacity for GlobalStandard SKU
171CURRENT_CAPACITY=$(echo "$CAPACITY_JSON" | jq -r '.value[] | select(.properties.skuName=="GlobalStandard") | .properties.availableCapacity')
172```
173 
174**Check result:**
175```bash
176if [ -n "$CURRENT_CAPACITY" ] && [ "$CURRENT_CAPACITY" -gt 0 ]; then
177  echo "✓ Current region ($PROJECT_REGION) has capacity: $CURRENT_CAPACITY TPM"
178  echo "Proceeding with deployment..."
179  # Skip to Phase 7 (Deploy)
180else
181  echo "⚠ Current region ($PROJECT_REGION) has no available capacity"
182  echo "Checking alternative regions..."
183  # Continue to Phase 5
184fi
185```
186 
187---
188 
189## Phase 5: Query Multi-Region Capacity (If Needed)
190 
191Only execute this phase if current region has no capacity.
192 
193**Query capacity across all regions:**
194```bash
195# Get capacity for all regions in subscription
196ALL_REGIONS_JSON=$(az rest --method GET \
197  --url "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/providers/Microsoft.CognitiveServices/modelCapacities?api-version=2024-10-01&modelFormat=$MODEL_FORMAT&modelName=$MODEL_NAME&modelVersion=$MODEL_VERSION")
198 
199# Save to file for processing
200echo "$ALL_REGIONS_JSON" > /tmp/capacity_check.json
201```
202 
203**Parse and categorize regions:**
204```bash
205# Extract available regions (capacity > 0)
206AVAILABLE_REGIONS=$(jq -r '.value[] | select(.properties.skuName=="GlobalStandard" and .properties.availableCapacity > 0) | "\(.location)|\(.properties.availableCapacity)"' /tmp/capacity_check.json)
207 
208# Extract unavailable regions (capacity = 0 or undefined)
209UNAVAILABLE_REGIONS=$(jq -r '.value[] | select(.properties.skuName=="GlobalStandard" and (.properties.availableCapacity == 0 or .properties.availableCapacity == null)) | "\(.location)|0"' /tmp/capacity_check.json)
210```
211 
212**Format and display regions:**
213```bash
214# Format capacity (e.g., 120000 -> 120K)
215format_capacity() {
216  local capacity=$1
217  if [ "$capacity" -ge 1000000 ]; then
218    echo "$(awk "BEGIN {printf \"%.1f\", $capacity/1000000}")M TPM"
219  elif [ "$capacity" -ge 1000 ]; then
220    echo "$(awk "BEGIN {printf \"%.0f\", $capacity/1000}")K TPM"
221  else
222    echo "$capacity TPM"
223  fi
224}
225 
226echo ""
227echo "⚠ No Capacity in Current Region"
228echo ""
229echo "The current project's region ($PROJECT_REGION) does not have available capacity for $MODEL_NAME."
230echo ""
231echo "Available Regions (with capacity):"
232echo ""
233 
234# Display available regions with formatted capacity
235echo "$AVAILABLE_REGIONS" | while IFS='|' read -r region capacity; do
236  formatted_capacity=$(format_capacity "$capacity")
237  # Get region display name (capitalize and format)
238  region_display=$(echo "$region" | sed 's/\([a-z]\)\([a-z]*\)/\U\1\L\2/g; s/\([a-z]\)\([0-9]\)/\1 \2/g')
239  echo "  • $region_display - $formatted_capacity"
240done
241 
242echo ""
243echo "Unavailable Regions:"
244echo ""
245 
246# Display unavailable regions
247echo "$UNAVAILABLE_REGIONS" | while IFS='|' read -r region capacity; do
248  region_display=$(echo "$region" | sed 's/\([a-z]\)\([a-z]*\)/\U\1\L\2/g; s/\([a-z]\)\([0-9]\)/\1 \2/g')
249  if [ "$capacity" = "0" ]; then
250    echo "  ✗ $region_display (Insufficient quota - 0 TPM available)"
251  else
252    echo "  ✗ $region_display (Model not supported)"
253  fi
254done
255```
256 
257**Handle no capacity anywhere:**
258```bash
259if [ -z "$AVAILABLE_REGIONS" ]; then
260  echo ""
261  echo "❌ No Available Capacity in Any Region"
262  echo ""
263  echo "No regions have available capacity for $MODEL_NAME with GlobalStandard SKU."
264  echo ""
265  echo "Next Steps:"
266  echo "1. Request quota increase — use the quota skill (../../../quota/quota.md)"
267  echo ""
268  echo "2. Check existing deployments (may be using quota):"
269  echo "   az cognitiveservices account deployment list \\"
270  echo "     --name $PROJECT_NAME \\"
271  echo "     --resource-group $RESOURCE_GROUP"
272  echo ""
273  echo "3. Consider alternative models with lower capacity requirements:"
274  echo "   • gpt-4o-mini (cost-effective, lower capacity requirements)"
275  echo "   List available models: az cognitiveservices account list-models --name \$PROJECT_NAME --resource-group \$RESOURCE_GROUP --output table"
276  exit 1
277fi
278```
279 
280---
281 
282## Phase 6: Select Region and Project
283 
284**Ask user to select region from available options.**
285 
286Example using AskUserQuestion:
287- Present available regions as options
288- Show capacity for each
289- User selects preferred region
290 
291**Store selection:**
292```bash
293SELECTED_REGION="<user-selected-region>"  # e.g., "eastus2"
294```
295 
296**Find projects in selected region:**
297```bash
298PROJECTS_IN_REGION=$(az cognitiveservices account list \
299  --query "[?kind=='AIProject' && location=='$SELECTED_REGION'].{Name:name, ResourceGroup:resourceGroup}" \
300  --output json)
301 
302PROJECT_COUNT=$(echo "$PROJECTS_IN_REGION" | jq '. | length')
303 
304if [ "$PROJECT_COUNT" -eq 0 ]; then
305  echo "No projects found in $SELECTED_REGION"
306  echo "Would you like to create a new project? (yes/no)"
307  # If yes, continue to project creation
308  # If no, exit or select different region
309else
310  echo "Projects in $SELECTED_REGION:"
311  echo "$PROJECTS_IN_REGION" | jq -r '.[] | "  • \(.Name) (\(.ResourceGroup))"'
312  echo ""
313  echo "Select a project or create new project"
314fi
315```
316 
317**Option A: Use existing project**
318```bash
319PROJECT_NAME="<selected-project-name>"
320RESOURCE_GROUP="<resource-group>"
321```
322 
323**Option B: Create new project**
324```bash
325# Generate project name
326USER_ALIAS=$(az account show --query user.name -o tsv | cut -d'@' -f1 | tr '.' '-')
327RANDOM_SUFFIX=$(openssl rand -hex 2)
328NEW_PROJECT_NAME="${USER_ALIAS}-aiproject-${RANDOM_SUFFIX}"
329 
330# Prompt for resource group
331echo "Resource group for new project:"
332echo "  1. Use existing resource group: $RESOURCE_GROUP"
333echo "  2. Create new resource group"
334 
335# If existing resource group
336NEW_RESOURCE_GROUP="$RESOURCE_GROUP"
337 
338# Create AI Services account (hub)
339HUB_NAME="${NEW_PROJECT_NAME}-hub"
340 
341echo "Creating AI Services hub: $HUB_NAME in $SELECTED_REGION..."
342 
343az cognitiveservices account create \
344  --name "$HUB_NAME" \
345  --resource-group "$NEW_RESOURCE_GROUP" \
346  --location "$SELECTED_REGION" \
347  --kind "AIServices" \
348  --sku "S0" \
349  --yes
350 
351# Create AI Foundry project
352echo "Creating AI Foundry project: $NEW_PROJECT_NAME..."
353 
354az cognitiveservices account create \
355  --name "$NEW_PROJECT_NAME" \
356  --resource-group "$NEW_RESOURCE_GROUP" \
357  --location "$SELECTED_REGION" \
358  --kind "AIProject" \
359  --sku "S0" \
360  --yes
361 
362echo "✓ Project created successfully"
363PROJECT_NAME="$NEW_PROJECT_NAME"
364RESOURCE_GROUP="$NEW_RESOURCE_GROUP"
365```
366 
367---
368 
369## Phase 7: Deploy Model
370 
371**Generate unique deployment name:**
372 
373The deployment name should match the model name (e.g., "gpt-4o"), but if a deployment with that name already exists, append a numeric suffix (e.g., "gpt-4o-2", "gpt-4o-3"). This follows the same UX pattern as Azure AI Foundry portal.
374 
375Use the `generate_deployment_name` script to check existing deployments and generate a unique name:
376 
377*Bash version:*
378```bash
379DEPLOYMENT_NAME=$(bash scripts/generate_deployment_name.sh \
380  "$ACCOUNT_NAME" \
381  "$RESOURCE_GROUP" \
382  "$MODEL_NAME")
383 
384echo "Generated deployment name: $DEPLOYMENT_NAME"
385```
386 
387*PowerShell version:*
388```powershell
389$DEPLOYMENT_NAME = & .\scripts\generate_deployment_name.ps1 `
390  -AccountName $ACCOUNT_NAME `
391  -ResourceGroup $RESOURCE_GROUP `
392  -ModelName $MODEL_NAME
393 
394Write-Host "Generated deployment name: $DEPLOYMENT_NAME"
395```
396 
397**Calculate deployment capacity:**
398 
399Follow UX capacity calculation logic. For OpenAI models, use 50% of available capacity (minimum 50 TPM). For all other models (MaaS), capacity is always 1:
400 
401```bash
402if [ "$MODEL_FORMAT" = "OpenAI" ]; then
403  # OpenAI models: TPM-based capacity (50% of available, minimum 50)
404  SELECTED_CAPACITY=$(echo "$ALL_REGIONS_JSON" | jq -r ".value[] | select(.location==\"$SELECTED_REGION\" and .properties.skuName==\"GlobalStandard\") | .properties.availableCapacity")
405 
406  if [ "$SELECTED_CAPACITY" -gt 50 ]; then
407    DEPLOY_CAPACITY=$((SELECTED_CAPACITY / 2))
408    if [ "$DEPLOY_CAPACITY" -lt 50 ]; then
409      DEPLOY_CAPACITY=50
410    fi
411  else
412    DEPLOY_CAPACITY=$SELECTED_CAPACITY
413  fi
414 
415  echo "Deploying with capacity: $DEPLOY_CAPACITY TPM (50% of available: $SELECTED_CAPACITY TPM)"
416else
417  # Non-OpenAI models (MaaS): capacity is always 1
418  DEPLOY_CAPACITY=1
419  echo "MaaS model — deploying with capacity: 1 (pay-per-token billing)"
420fi
421```
422 
423### If MODEL_FORMAT is NOT "Anthropic" — Standard CLI Deployment
424 
425> 💡 **Note:** The Azure CLI supports all non-Anthropic model formats directly.
426 
427*Bash version:*
428```bash
429echo "Creating deployment..."
430 
431az cognitiveservices account deployment create \
432  --name "$ACCOUNT_NAME" \
433  --resource-group "$RESOURCE_GROUP" \
434  --deployment-name "$DEPLOYMENT_NAME" \
435  --model-name "$MODEL_NAME" \
436  --model-version "$MODEL_VERSION" \
437  --model-format "$MODEL_FORMAT" \
438  --sku-name "GlobalStandard" \
439  --sku-capacity "$DEPLOY_CAPACITY"
440```
441 
442*PowerShell version:*
443```powershell
444Write-Host "Creating deployment..."
445 
446az cognitiveservices account deployment create `
447  --name $ACCOUNT_NAME `
448  --resource-group $RESOURCE_GROUP `
449  --deployment-name $DEPLOYMENT_NAME `
450  --model-name $MODEL_NAME `
451  --model-version $MODEL_VERSION `
452  --model-format $MODEL_FORMAT `
453  --sku-name "GlobalStandard" `
454  --sku-capacity $DEPLOY_CAPACITY
455```
456 
457> 💡 **Note:** For non-OpenAI MaaS models (Meta-Llama, Mistral, Cohere, etc.), `$DEPLOY_CAPACITY` is `1` (set in capacity calculation above).
458 
459### If MODEL_FORMAT is "Anthropic" — REST API Deployment with modelProviderData
460 
461The Azure CLI does not support `--model-provider-data`. You must use the ARM REST API directly.
462 
463**Step 1: Prompt user to select industry**
464 
465Present the following list and ask the user to choose one:
466 
467```
468 1. None                    (API value: none)
469 2. Biotechnology           (API value: biotechnology)
470 3. Consulting              (API value: consulting)
471 4. Education               (API value: education)
472 5. Finance                 (API value: finance)
473 6. Food & Beverage         (API value: food_and_beverage)
474 7. Government              (API value: government)
475 8. Healthcare              (API value: healthcare)
476 9. Insurance               (API value: insurance)
47710. Law                     (API value: law)
47811. Manufacturing           (API value: manufacturing)
47912. Media                   (API value: media)
48013. Nonprofit               (API value: nonprofit)
48114. Technology              (API value: technology)
48215. Telecommunications      (API value: telecommunications)
48316. Sport & Recreation      (API value: sport_and_recreation)
48417. Real Estate             (API value: real_estate)
48518. Retail                  (API value: retail)
48619. Other                   (API value: other)
487```
488 
489> ⚠️ **Do NOT pick a default industry or hardcode a value. Always ask the user.** This is required by Anthropic's terms of service. The industry list is static — there is no REST API that provides it.
490 
491Store selection as `SELECTED_INDUSTRY` (use the API value, e.g., `technology`).
492 
493**Step 2: Fetch tenant info (country code and organization name)**
494 
495```bash
496TENANT_INFO=$(az rest --method GET \
497  --url "https://management.azure.com/tenants?api-version=2024-11-01" \
498  --query "value[0].{countryCode:countryCode, displayName:displayName}" -o json)
499 
500COUNTRY_CODE=$(echo "$TENANT_INFO" | jq -r '.countryCode')
501ORG_NAME=$(echo "$TENANT_INFO" | jq -r '.displayName')
502```
503 
504*PowerShell version:*
505```powershell
506$tenantInfo = az rest --method GET `
507  --url "https://management.azure.com/tenants?api-version=2024-11-01" `
508  --query "value[0].{countryCode:countryCode, displayName:displayName}" -o json | ConvertFrom-Json
509 
510$countryCode = $tenantInfo.countryCode
511$orgName = $tenantInfo.displayName
512```
513 
514**Step 3: Deploy via ARM REST API**
515 
516*Bash version:*
517```bash
518echo "Creating Anthropic model deployment via REST API..."
519 
520az rest --method PUT \
521  --url "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.CognitiveServices/accounts/$ACCOUNT_NAME/deployments/$DEPLOYMENT_NAME?api-version=2024-10-01" \
522  --body "{
523    \"sku\": {
524      \"name\": \"GlobalStandard\",
525      \"capacity\": 1
526    },
527    \"properties\": {
528      \"model\": {
529        \"format\": \"Anthropic\",
530        \"name\": \"$MODEL_NAME\",
531        \"version\": \"$MODEL_VERSION\"
532      },
533      \"modelProviderData\": {
534        \"industry\": \"$SELECTED_INDUSTRY\",
535        \"countryCode\": \"$COUNTRY_CODE\",
536        \"organizationName\": \"$ORG_NAME\"
537      }
538    }
539  }"
540```
541 
542*PowerShell version:*
543```powershell
544Write-Host "Creating Anthropic model deployment via REST API..."
545 
546$body = @{
547    sku = @{
548        name = "GlobalStandard"
549        capacity = 1
550    }
551    properties = @{
552        model = @{
553            format = "Anthropic"
554            name = $MODEL_NAME
555            version = $MODEL_VERSION
556        }
557        modelProviderData = @{
558            industry = $SELECTED_INDUSTRY
559            countryCode = $countryCode
560            organizationName = $orgName
561        }
562    }
563} | ConvertTo-Json -Depth 5
564 
565az rest --method PUT `
566  --url "https://management.azure.com/subscriptions/$SUBSCRIPTION_ID/resourceGroups/$RESOURCE_GROUP/providers/Microsoft.CognitiveServices/accounts/$ACCOUNT_NAME/deployments/${DEPLOYMENT_NAME}?api-version=2024-10-01" `
567  --body $body
568```
569 
570> 💡 **Note:** Anthropic models use `capacity: 1` (MaaS billing model), not TPM-based capacity.
571 
572**Monitor deployment progress:**
573```bash
574echo "Monitoring deployment status..."
575 
576MAX_WAIT=300  # 5 minutes
577ELAPSED=0
578INTERVAL=10
579 
580while [ $ELAPSED -lt $MAX_WAIT ]; do
581  STATUS=$(az cognitiveservices account deployment show \
582    --name "$ACCOUNT_NAME" \
583    --resource-group "$RESOURCE_GROUP" \
584    --deployment-name "$DEPLOYMENT_NAME" \
585    --query "properties.provisioningState" -o tsv 2>/dev/null)
586 
587  case "$STATUS" in
588    "Succeeded")
589      echo "✓ Deployment successful!"
590      break
591      ;;
592    "Failed")
593      echo "❌ Deployment failed"
594      # Get error details
595      az cognitiveservices account deployment show \
596        --name "$ACCOUNT_NAME" \
597        --resource-group "$RESOURCE_GROUP" \
598        --deployment-name "$DEPLOYMENT_NAME" \
599        --query "properties"
600      exit 1
601      ;;
602    "Creating"|"Accepted"|"Running")
603      echo "Status: $STATUS... (${ELAPSED}s elapsed)"
604      sleep $INTERVAL
605      ELAPSED=$((ELAPSED + INTERVAL))
606      ;;
607    *)
608      echo "Unknown status: $STATUS"
609      sleep $INTERVAL
610      ELAPSED=$((ELAPSED + INTERVAL))
611      ;;
612  esac
613done
614 
615if [ $ELAPSED -ge $MAX_WAIT ]; then
616  echo "⚠ Deployment timeout after ${MAX_WAIT}s"
617  echo "Check status manually:"
618  echo "  az cognitiveservices account deployment show \\"
619  echo "    --name $ACCOUNT_NAME \\"
620  echo "    --resource-group $RESOURCE_GROUP \\"
621  echo "    --deployment-name $DEPLOYMENT_NAME"
622  exit 1
623fi
624```
625 
626---
627 
628## Phase 8: Display Deployment Details
629 
630**Show deployment information:**
631```bash
632echo ""
633echo "═══════════════════════════════════════════"
634echo "✓ Deployment Successful!"
635echo "═══════════════════════════════════════════"
636echo ""
637 
638# Get endpoint information
639ENDPOINT=$(az cognitiveservices account show \
640  --name "$ACCOUNT_NAME" \
641  --resource-group "$RESOURCE_GROUP" \
642  --query "properties.endpoint" -o tsv)
643 
644# Get deployment details
645DEPLOYMENT_INFO=$(az cognitiveservices account deployment show \
646  --name "$ACCOUNT_NAME" \
647  --resource-group "$RESOURCE_GROUP" \
648  --deployment-name "$DEPLOYMENT_NAME" \
649  --query "properties.model")
650 
651echo "Deployment Name: $DEPLOYMENT_NAME"
652echo "Model: $MODEL_NAME"
653echo "Version: $MODEL_VERSION"
654echo "Region: $SELECTED_REGION"
655echo "SKU: GlobalStandard"
656echo "Capacity: $(format_capacity $DEPLOY_CAPACITY)"
657echo "Endpoint: $ENDPOINT"
658echo ""
659 
660# Generate direct link to deployment in Azure AI Foundry portal
661DEPLOYMENT_URL=$(bash "$(dirname "$0")/scripts/generate_deployment_url.sh" \
662  --subscription "$SUBSCRIPTION_ID" \
663  --resource-group "$RESOURCE_GROUP" \
664  --foundry-resource "$ACCOUNT_NAME" \
665  --project "$PROJECT_NAME" \
666  --deployment "$DEPLOYMENT_NAME")
667 
668echo "🔗 View in Azure AI Foundry Portal:"
669echo ""
670echo "$DEPLOYMENT_URL"
671echo ""
672echo "═══════════════════════════════════════════"
673echo ""
674 
675echo "Test your deployment:"
676echo ""
677echo "# View deployment details"
678echo "az cognitiveservices account deployment show \\"
679echo "  --name $ACCOUNT_NAME \\"
680echo "  --resource-group $RESOURCE_GROUP \\"
681echo "  --deployment-name $DEPLOYMENT_NAME"
682echo ""
683echo "# List all deployments"
684echo "az cognitiveservices account deployment list \\"
685echo "  --name $ACCOUNT_NAME \\"
686echo "  --resource-group $RESOURCE_GROUP \\"
687echo "  --output table"
688echo ""
689 
690echo "Next steps:"
691echo "• Click the link above to test in Azure AI Foundry playground"
692echo "• Integrate into your application"
693echo "• Set up monitoring and alerts"
694```
695