Pianificazione della capacità - Disponibilità e limiti delle risorse di Azure

February 9, 2026 · View on GitHub

Chapter Navigation:

Introduzione

Questa guida completa ti aiuta a pianificare e convalidare la capacità delle risorse Azure prima di distribuire con Azure Developer CLI. Impara a valutare quote, disponibilità e limitazioni regionali per garantire distribuzioni di successo ottimizzando costi e prestazioni. Padroneggia le tecniche di pianificazione della capacità per diverse architetture applicative e scenari di scalabilità.

Obiettivi di apprendimento

Completando questa guida, sarai in grado di:

  • Comprendere le quote, i limiti e i vincoli di disponibilità regionale di Azure
  • Padroneggiare le tecniche per verificare la disponibilità e la capacità delle risorse prima della distribuzione
  • Implementare strategie automatizzate di convalida della capacità e di monitoraggio
  • Progettare applicazioni con dimensionamento delle risorse e considerazioni sulla scalabilità adeguate
  • Applicare strategie di ottimizzazione dei costi attraverso una pianificazione della capacità intelligente
  • Configurare avvisi e monitoraggio per l'utilizzo delle quote e la disponibilità delle risorse

Risultati di apprendimento

Al termine, sarai in grado di:

  • Valutare e convalidare i requisiti di capacità delle risorse Azure prima della distribuzione
  • Creare script automatizzati per il controllo della capacità e il monitoraggio delle quote
  • Progettare architetture scalabili che tengano conto dei limiti regionali e della sottoscrizione
  • Implementare strategie di dimensionamento delle risorse economicamente efficienti per diversi tipi di carico di lavoro
  • Configurare monitoraggio proattivo e avvisi per problemi legati alla capacità
  • Pianificare distribuzioni multi-regione con una corretta distribuzione della capacità

Perché la pianificazione della capacità è importante

Prima di distribuire applicazioni, devi assicurarti di:

  • Quote sufficienti per le risorse richieste
  • Disponibilità delle risorse nella regione di destinazione
  • Disponibilità del livello di servizio per il tipo di sottoscrizione
  • Capacità di rete per il traffico previsto
  • Ottimizzazione dei costi attraverso un dimensionamento adeguato

📊 Comprendere le quote e i limiti di Azure

Tipi di limiti

  1. Quote a livello di sottoscrizione - Numero massimo di risorse per sottoscrizione
  2. Quote regionali - Numero massimo di risorse per regione
  3. Limiti specifici delle risorse - Limiti per singoli tipi di risorsa
  4. Limiti del livello di servizio - Limiti basati sul piano di servizio

Quote comuni delle risorse

# Verifica l'utilizzo corrente della quota
az vm list-usage --location eastus2 --output table

# Verifica le quote di risorse specifiche
az network list-usages --location eastus2 --output table
az storage account show-usage --output table

Controlli della capacità prima della distribuzione

Script di convalida della capacità automatizzato

#!/bin/bash
# capacity-check.sh - Verifica della capacità di Azure prima della distribuzione

set -e

LOCATION=${1:-eastus2}
SUBSCRIPTION_ID=$(az account show --query id -o tsv)

echo "Checking Azure capacity for location: $LOCATION"
echo "Subscription: $SUBSCRIPTION_ID"
echo "======================================================"

# Funzione per verificare l'utilizzo delle quote
check_quota() {
    local resource_type=\$1
    local required=\$2
    
    echo "Checking $resource_type quota..."
    
    case $resource_type in
        "compute")
            usage=$(az vm list-usage --location "$LOCATION" --query "[?localName=='Total Regional vCPUs'].{current:currentValue,limit:limit}" -o json)
            current=$(echo "$usage" | jq -r '.[0].current')
            limit=$(echo "$usage" | jq -r '.[0].limit')
            ;;
        "storage")
            usage=$(az storage account show-usage --query "{current:value,limit:limit}" -o json)
            current=$(echo "$usage" | jq -r '.current')
            limit=$(echo "$usage" | jq -r '.limit')
            ;;
        "network")
            usage=$(az network list-usages --location "$LOCATION" --query "[?localName=='Virtual Networks'].{current:currentValue,limit:limit}" -o json)
            current=$(echo "$usage" | jq -r '.[0].current')
            limit=$(echo "$usage" | jq -r '.[0].limit')
            ;;
    esac
    
    available=$((limit - current))
    
    if [ "$available" -ge "$required" ]; then
        echo "✅ $resource_type: $available/$limit available (need $required)"
    else
        echo "❌ $resource_type: Only $available/$limit available (need $required)"
        return 1
    fi
}

# Verifica varie quote di risorse
check_quota "compute" 4      # Sono necessari 4 vCPU
check_quota "storage" 2      # Sono necessari 2 account di archiviazione
check_quota "network" 1      # È necessaria 1 rete virtuale

echo "======================================================"
echo "✅ Capacity check completed successfully!"

Controlli della capacità specifici per servizio

Capacità di App Service

# Verifica la disponibilità del piano App Service
check_app_service_capacity() {
    local location=\$1
    local sku=\$2
    
    echo "Checking App Service Plan capacity for $sku in $location"
    
    # Verifica gli SKU disponibili nella regione
    available_skus=$(az appservice list-locations --sku "$sku" --query "[?name=='$location']" -o tsv)
    
    if [ -n "$available_skus" ]; then
        echo "✅ $sku is available in $location"
    else
        echo "❌ $sku is not available in $location"
        
        # Suggerisci regioni alternative
        echo "Available regions for $sku:"
        az appservice list-locations --sku "$sku" --query "[].name" -o table
        return 1
    fi
    
    # Verifica l'utilizzo corrente
    current_plans=$(az appservice plan list --query "length([?location=='$location' && sku.name=='$sku'])")
    echo "Current $sku plans in $location: $current_plans"
}

# Utilizzo
check_app_service_capacity "eastus2" "P1v3"

Capacità del database

# Verifica la capacità di PostgreSQL
check_postgres_capacity() {
    local location=\$1
    local sku=\$2
    
    echo "Checking PostgreSQL capacity for $sku in $location"
    
    # Verifica se lo SKU è disponibile
    available=$(az postgres flexible-server list-skus --location "$location" \
        --query "contains([].name, '$sku')" -o tsv)
    
    if [ "$available" = "true" ]; then
        echo "✅ PostgreSQL $sku is available in $location"
    else
        echo "❌ PostgreSQL $sku is not available in $location"
        
        # Mostra gli SKU disponibili
        echo "Available PostgreSQL SKUs in $location:"
        az postgres flexible-server list-skus --location "$location" \
            --query "[].{name:name,tier:tier,vCores:vCores,memory:memorySizeInMb}" -o table
        return 1
    fi
}

# Verifica la capacità di Cosmos DB
check_cosmos_capacity() {
    local location=\$1
    local tier=\$2
    
    echo "Checking Cosmos DB capacity in $location"
    
    # Verifica la disponibilità della regione
    available_regions=$(az cosmosdb locations list --query "[?name=='$location']" -o tsv)
    
    if [ -n "$available_regions" ]; then
        echo "✅ Cosmos DB is available in $location"
        
        # Verifica se il serverless è supportato (se necessario)
        if [ "$tier" = "serverless" ]; then
            serverless_regions=$(az cosmosdb locations list \
                --query "[?supportsAvailabilityZone==true && name=='$location']" -o tsv)
            
            if [ -n "$serverless_regions" ]; then
                echo "✅ Cosmos DB Serverless is supported in $location"
            else
                echo "⚠️  Cosmos DB Serverless may not be supported in $location"
            fi
        fi
    else
        echo "❌ Cosmos DB is not available in $location"
        return 1
    fi
}

Capacità di Container Apps

# Controlla la capacità di Container Apps
check_container_apps_capacity() {
    local location=\$1
    
    echo "Checking Container Apps capacity in $location"
    
    # Controlla se Container Apps è disponibile nella regione
    az provider show --namespace Microsoft.App \
        --query "resourceTypes[?resourceType=='containerApps'].locations" \
        --output table | grep -q "$location"
    
    if [ $? -eq 0 ]; then
        echo "✅ Container Apps is available in $location"
        
        # Controlla il numero attuale di ambienti
        current_envs=$(az containerapp env list \
            --query "length([?location=='$location'])")
        
        echo "Current Container App environments in $location: $current_envs"
        
        # Container Apps ha un limite di 15 ambienti per regione
        if [ "$current_envs" -lt 15 ]; then
            echo "✅ Can create more Container App environments"
        else
            echo "⚠️  Near Container App environment limit in $location"
        fi
    else
        echo "❌ Container Apps is not available in $location"
        
        # Mostra le regioni disponibili
        echo "Available regions for Container Apps:"
        az provider show --namespace Microsoft.App \
            --query "resourceTypes[?resourceType=='containerApps'].locations[0:10]" \
            --output table
        return 1
    fi
}

📍 Validazione della disponibilità regionale

Disponibilità del servizio per regione

# Verifica la disponibilità del servizio nelle diverse regioni
check_service_availability() {
    local service=\$1
    
    echo "Checking $service availability across regions..."
    
    case $service in
        "appservice")
            az appservice list-locations --query "[].{region:name,displayName:displayName}" -o table
            ;;
        "containerapp")
            az provider show --namespace Microsoft.App \
                --query "resourceTypes[?resourceType=='containerApps'].locations" -o table
            ;;
        "postgres")
            az postgres flexible-server list-skus --location eastus2 >/dev/null 2>&1 && \
            echo "PostgreSQL Flexible Server regions:" && \
            az account list-locations --query "[?metadata.regionType=='Physical'].{name:name,displayName:displayName}" -o table
            ;;
        "cosmosdb")
            az cosmosdb locations list --query "[].{name:name,documentationUrl:documentationUrl}" -o table
            ;;
    esac
}

# Verifica tutti i servizi
for service in appservice containerapp postgres cosmosdb; do
    check_service_availability "$service"
    echo ""
done

Raccomandazioni per la selezione della regione

# Consiglia le regioni ottimali in base ai requisiti
recommend_region() {
    local requirements=\$1  # "economico" | "prestazioni" | "conformità"
    
    echo "Region recommendations for: $requirements"
    
    case $requirements in
        "lowcost")
            echo "💰 Cost-optimized regions:"
            echo "  - East US (Virginia)"
            echo "  - South Central US (Texas)"
            echo "  - West US 2 (Washington)"
            ;;
        "performance")
            echo "⚡ Performance-optimized regions:"
            echo "  - East US 2 (Virginia) - Latest hardware"
            echo "  - West US 2 (Washington) - Latest hardware"
            echo "  - North Europe (Ireland) - For EU users"
            ;;
        "compliance")
            echo "🔒 Compliance-focused regions:"
            echo "  - US Gov regions - For government workloads"
            echo "  - Germany regions - For GDPR compliance"
            echo "  - Australia regions - For data sovereignty"
            ;;
    esac
}

💰 Pianificazione e stima dei costi

Stima dei costi delle risorse

# Stima i costi di distribuzione
estimate_costs() {
    local resource_group=\$1
    local location=\$2
    
    echo "Estimating costs for deployment in $location"
    
    # Crea un gruppo di risorse temporaneo per la stima
    temp_rg="temp-estimation-$(date +%s)"
    az group create --name "$temp_rg" --location "$location" >/dev/null
    
    # Distribuisci l'infrastruttura in modalità di convalida
    az deployment group validate \
        --resource-group "$temp_rg" \
        --template-file infra/main.bicep \
        --parameters @infra/main.parameters.json \
        --parameters location="$location" \
        --query "properties.validatedResources[].{type:type,name:name}" -o table
    
    # Elimina il gruppo di risorse temporaneo
    az group delete --name "$temp_rg" --yes --no-wait
    
    echo ""
    echo "💡 Use Azure Pricing Calculator for detailed cost estimates:"
    echo "   https://azure.microsoft.com/pricing/calculator/"
    echo ""
    echo "💡 Consider using Azure Cost Management for ongoing monitoring:"
    echo "   https://portal.azure.com/#blade/Microsoft_Azure_CostManagement/Menu/overview"
}

Raccomandazioni per l'ottimizzazione degli SKU

# Consiglia gli SKU ottimali in base ai requisiti
recommend_sku() {
    local service=\$1
    local workload_type=\$2  # "sviluppo" | "pre-produzione" | "produzione"
    
    echo "SKU recommendations for $service ($workload_type workload):"
    
    case $service in
        "appservice")
            case $workload_type in
                "dev")
                    echo "  Recommended: B1 (Basic)"
                    echo "  Alternative: F1 (Free) for temporary testing"
                    ;;
                "staging")
                    echo "  Recommended: S1 (Standard)"
                    echo "  Alternative: B2 (Basic) for cost savings"
                    ;;
                "production")
                    echo "  Recommended: P1v3 (Premium)"
                    echo "  High-traffic: P2v3 or P3v3"
                    echo "  Consider: App Service Environment for isolation"
                    ;;
            esac
            ;;
        "postgres")
            case $workload_type in
                "dev")
                    echo "  Recommended: Standard_B1ms (Burstable)"
                    echo "  Storage: 32 GB"
                    ;;
                "staging")
                    echo "  Recommended: Standard_B2s (Burstable)"
                    echo "  Storage: 64 GB"
                    ;;
                "production")
                    echo "  Recommended: Standard_D2s_v3 (General Purpose)"
                    echo "  High-performance: Standard_D4s_v3 or higher"
                    echo "  Storage: 128 GB or more with backup"
                    ;;
            esac
            ;;
        "cosmosdb")
            case $workload_type in
                "dev")
                    echo "  Recommended: Serverless"
                    echo "  Alternative: Provisioned 400 RU/s"
                    ;;
                "staging")
                    echo "  Recommended: Provisioned 400-1000 RU/s"
                    echo "  Enable autoscale for variable workloads"
                    ;;
                "production")
                    echo "  Recommended: Provisioned with autoscale"
                    echo "  High-availability: Multi-region writes"
                    echo "  Consider: Dedicated throughput for containers"
                    ;;
            esac
            ;;
    esac
}

🚀 Verifiche preliminari automatizzate

Script di verifica preliminare completo

#!/bin/bash
# preflight-check.sh - Validazione completa prima della distribuzione

set -e

# Configurazione
LOCATION=${1:-eastus2}
ENVIRONMENT=${2:-dev}
CONFIG_FILE="preflight-config.json"

# Colori per l'output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # Nessun colore

# Funzioni di logging
log_info() { echo -e "${GREEN}ℹ️  \$1${NC}"; }
log_warn() { echo -e "${YELLOW}⚠️  \$1${NC}"; }
log_error() { echo -e "${RED}❌ \$1${NC}"; }

# Carica la configurazione
if [ -f "$CONFIG_FILE" ]; then
    REQUIRED_VCPUS=$(jq -r '.requirements.vcpus' "$CONFIG_FILE")
    REQUIRED_STORAGE=$(jq -r '.requirements.storage' "$CONFIG_FILE")
    REQUIRED_SERVICES=($(jq -r '.requirements.services[]' "$CONFIG_FILE"))
else
    log_warn "No configuration file found, using defaults"
    REQUIRED_VCPUS=4
    REQUIRED_STORAGE=2
    REQUIRED_SERVICES=("appservice" "postgres" "storage")
fi

echo "🚀 Starting pre-flight checks..."
echo "Location: $LOCATION"
echo "Environment: $ENVIRONMENT"
echo "Required vCPUs: $REQUIRED_VCPUS"
echo "Required Storage Accounts: $REQUIRED_STORAGE"
echo "Required Services: ${REQUIRED_SERVICES[*]}"
echo "=================================="

# Controllo 1: Autenticazione
log_info "Checking Azure authentication..."
if az account show >/dev/null 2>&1; then
    SUBSCRIPTION_NAME=$(az account show --query name -o tsv)
    log_info "Authenticated with subscription: $SUBSCRIPTION_NAME"
else
    log_error "Not authenticated with Azure. Run 'az login' first."
    exit 1
fi

# Controllo 2: Disponibilità regionale
log_info "Checking regional availability..."
if az account list-locations --query "[?name=='$LOCATION']" | grep -q "$LOCATION"; then
    log_info "Region $LOCATION is available"
else
    log_error "Region $LOCATION is not available"
    exit 1
fi

# Controllo 3: Verifica delle quote
log_info "Checking quota availability..."

# Quota vCPU
vcpu_usage=$(az vm list-usage --location "$LOCATION" \
    --query "[?localName=='Total Regional vCPUs'].{current:currentValue,limit:limit}" -o json)
vcpu_current=$(echo "$vcpu_usage" | jq -r '.[0].current')
vcpu_limit=$(echo "$vcpu_usage" | jq -r '.[0].limit')
vcpu_available=$((vcpu_limit - vcpu_current))

if [ "$vcpu_available" -ge "$REQUIRED_VCPUS" ]; then
    log_info "vCPU quota: $vcpu_available/$vcpu_limit available (need $REQUIRED_VCPUS)"
else
    log_error "Insufficient vCPU quota: $vcpu_available/$vcpu_limit available (need $REQUIRED_VCPUS)"
    exit 1
fi

# Quota dell'account di archiviazione
storage_usage=$(az storage account show-usage --query "{current:value,limit:limit}" -o json)
storage_current=$(echo "$storage_usage" | jq -r '.current')
storage_limit=$(echo "$storage_usage" | jq -r '.limit')
storage_available=$((storage_limit - storage_current))

if [ "$storage_available" -ge "$REQUIRED_STORAGE" ]; then
    log_info "Storage quota: $storage_available/$storage_limit available (need $REQUIRED_STORAGE)"
else
    log_error "Insufficient storage quota: $storage_available/$storage_limit available (need $REQUIRED_STORAGE)"
    exit 1
fi

# Controllo 4: Disponibilità del servizio
log_info "Checking service availability..."

for service in "${REQUIRED_SERVICES[@]}"; do
    case $service in
        "appservice")
            if az appservice list-locations --sku B1 --query "[?name=='$LOCATION']" | grep -q "$LOCATION"; then
                log_info "App Service is available in $LOCATION"
            else
                log_error "App Service is not available in $LOCATION"
                exit 1
            fi
            ;;
        "postgres")
            if az postgres flexible-server list-skus --location "$LOCATION" >/dev/null 2>&1; then
                log_info "PostgreSQL is available in $LOCATION"
            else
                log_error "PostgreSQL is not available in $LOCATION"
                exit 1
            fi
            ;;
        "containerapp")
            if az provider show --namespace Microsoft.App \
                --query "resourceTypes[?resourceType=='containerApps'].locations" \
                --output tsv | grep -q "$LOCATION"; then
                log_info "Container Apps is available in $LOCATION"
            else
                log_error "Container Apps is not available in $LOCATION"
                exit 1
            fi
            ;;
        "cosmosdb")
            if az cosmosdb locations list --query "[?name=='$LOCATION']" | grep -q "$LOCATION"; then
                log_info "Cosmos DB is available in $LOCATION"
            else
                log_error "Cosmos DB is not available in $LOCATION"
                exit 1
            fi
            ;;
    esac
done

# Controllo 5: Capacità di rete
log_info "Checking network capacity..."
vnet_usage=$(az network list-usages --location "$LOCATION" \
    --query "[?localName=='Virtual Networks'].{current:currentValue,limit:limit}" -o json)
vnet_current=$(echo "$vnet_usage" | jq -r '.[0].current')
vnet_limit=$(echo "$vnet_usage" | jq -r '.[0].limit')
vnet_available=$((vnet_limit - vnet_current))

if [ "$vnet_available" -gt 0 ]; then
    log_info "Virtual Network quota: $vnet_available/$vnet_limit available"
else
    log_warn "Virtual Network quota: $vnet_available/$vnet_limit available (may need cleanup)"
fi

# Controllo 6: Validazione dei nomi delle risorse
log_info "Checking resource naming conventions..."
RESOURCE_TOKEN=$(echo -n "${SUBSCRIPTION_ID}${ENVIRONMENT}${LOCATION}" | sha256sum | cut -c1-8)
STORAGE_NAME="myapp${ENVIRONMENT}sa${RESOURCE_TOKEN}"

if [ ${#STORAGE_NAME} -le 24 ] && [[ "$STORAGE_NAME" =~ ^[a-z0-9]+$ ]]; then
    log_info "Storage account naming is valid: $STORAGE_NAME"
else
    log_error "Storage account naming is invalid: $STORAGE_NAME"
    exit 1
fi

# Controllo 7: Stima dei costi
log_info "Performing cost estimation..."
ESTIMATED_MONTHLY_COST=$(calculate_estimated_cost "$ENVIRONMENT" "$LOCATION")
log_info "Estimated monthly cost: \$${ESTIMATED_MONTHLY_COST}"

if [ "$ENVIRONMENT" = "production" ] && [ "$ESTIMATED_MONTHLY_COST" -gt 1000 ]; then
    log_warn "High estimated cost for production environment: \$${ESTIMATED_MONTHLY_COST}/month"
    read -p "Continue with deployment? (y/n): " -n 1 -r
    echo
    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
        log_info "Deployment cancelled by user"
        exit 1
    fi
fi

# Controllo 8: Validazione del template
log_info "Validating Bicep templates..."
if [ -f "infra/main.bicep" ]; then
    if az bicep build --file infra/main.bicep --stdout >/dev/null 2>&1; then
        log_info "Bicep template syntax is valid"
    else
        log_error "Bicep template has syntax errors"
        az bicep build --file infra/main.bicep
        exit 1
    fi
else
    log_warn "No Bicep template found at infra/main.bicep"
fi

# Riepilogo finale
echo "=================================="
log_info "✅ All pre-flight checks passed!"
log_info "Ready for deployment to $LOCATION"
echo "Next steps:"
echo "  1. Run 'azd up' to deploy"
echo "  2. Monitor deployment progress"
echo "  3. Verify application health post-deployment"

Modello di file di configurazione

{
  "requirements": {
    "vcpus": 4,
    "storage": 2,
    "services": [
      "appservice",
      "postgres",
      "storage"
    ]
  },
  "preferences": {
    "region": "eastus2",
    "costOptimized": true,
    "highAvailability": false
  },
  "skus": {
    "dev": {
      "appServiceSku": "B1",
      "databaseSku": "Standard_B1ms"
    },
    "staging": {
      "appServiceSku": "S1",
      "databaseSku": "Standard_B2s"
    },
    "production": {
      "appServiceSku": "P1v3",
      "databaseSku": "Standard_D2s_v3"
    }
  }
}

📈 Monitoraggio della capacità durante la distribuzione

Monitoraggio della capacità in tempo reale

# Monitorare la capacità durante la distribuzione
monitor_deployment_capacity() {
    local resource_group=\$1
    
    echo "Monitoring capacity during deployment..."
    
    while true; do
        # Verificare lo stato della distribuzione
        deployment_status=$(az deployment group list \
            --resource-group "$resource_group" \
            --query "[0].properties.provisioningState" -o tsv)
        
        if [ "$deployment_status" = "Succeeded" ]; then
            log_info "Deployment completed successfully"
            break
        elif [ "$deployment_status" = "Failed" ]; then
            log_error "Deployment failed"
            break
        fi
        
        # Controllare l'utilizzo corrente delle risorse
        current_resources=$(az resource list \
            --resource-group "$resource_group" \
            --query "length([])")
        
        echo "$(date): Deployment in progress, $current_resources resources created"
        sleep 30
    done
}

🔗 Integrazione con AZD

Aggiungi hook di verifica preliminare a azure.yaml

# azure.yaml
hooks:
  preprovision:
    shell: sh
    run: |
      echo "Running pre-flight capacity checks..."
      ./scripts/preflight-check.sh ${AZURE_LOCATION} ${AZURE_ENV_NAME}
      
      if [ $? -ne 0 ]; then
        echo "Pre-flight checks failed"
        exit 1
      fi
      
      echo "Pre-flight checks passed, proceeding with deployment"

Migliori pratiche

  1. Esegui sempre i controlli di capacità prima di distribuire in nuove regioni
  2. Monitora regolarmente l'utilizzo delle quote per evitare sorprese
  3. Pianifica la crescita verificando le future necessità di capacità
  4. Usa strumenti di stima dei costi per evitare sorprese in fattura
  5. Documenta i requisiti di capacità per il tuo team
  6. Automatizza la convalida della capacità nelle pipeline CI/CD
  7. Considera i requisiti di capacità per il failover regionale

Passaggi successivi

Risorse aggiuntive

Navigation

Dichiarazione di non responsabilità: Questo documento è stato tradotto utilizzando il servizio di traduzione automatica Co-op Translator. Sebbene ci impegniamo per l'accuratezza, si prega di notare che le traduzioni automatiche possono contenere errori o imprecisioni. Il documento originale nella sua lingua d'origine deve essere considerato la fonte autorevole. Per informazioni critiche, si raccomanda una traduzione professionale a cura di un traduttore umano. Non ci riteniamo responsabili per eventuali malintesi o interpretazioni errate derivanti dall'uso di questa traduzione.