Calcolare le dimensioni di fatturazione totali di un contenitore BLOB

Questo script calcola le dimensioni di un contenitore nell'archivio BLOB di Azure allo scopo di stimare i costi per la fatturazione. Lo script somma le dimensioni dei BLOB nel contenitore.

Importante

Lo script di esempio fornito in questo articolo potrebbe non calcolare in modo preciso le dimensioni di fatturazione per gli snapshot dei BLOB.

Questo esempio richiede Azure PowerShell. Eseguire Get-Module -ListAvailable Az per trovare la versione. Se è necessario eseguire l'installazione o l'aggiornamento, vedere come installare il modulo Azure PowerShell.

Eseguire il cmdlet Connect-AzAccount per connettersi ad Azure.

Se non si ha una sottoscrizione di Azure, creare un account Azure gratuito prima di iniziare.

Nota

Questo script di PowerShell calcola le dimensioni di un contenitore ai fini della fatturazione. In caso di calcolo delle dimensioni del contenitore per altri scopi, vedere l'articolo su come calcolare le dimensioni totali di un contenitore di archiviazione BLOB per uno script più semplice che offre una stima.

Determinare le dimensioni di un contenitore BLOB

La dimensione totale del contenitore BLOB include la dimensione del contenitore stesso e di tutti i BLOB in esso contenuti.

Nelle sezioni seguenti viene illustrata la modalità di calcolo della capacità di archiviazione per i contenitori BLOB e i BLOB. Nella sezione seguente Len(X) indica il numero di caratteri nella stringa.

Contenitori BLOB

Nel calcolo seguente viene descritto come calcolare la quantità di spazio di archiviazione usato per il contenitore BLOB:

48 bytes + Len(ContainerName) * 2 bytes +
For-Each Metadata[3 bytes + Len(MetadataName) + Len(Value)] +
For-Each Signed Identifier[512 bytes]

I dettagli sono indicati di seguito:

• 48 byte di sovraccarico per ogni contenitore include ora dell'ultima modifica, autorizzazioni, impostazioni pubbliche e alcuni metadati di sistema.

• Il nome del contenitore viene archiviato come Unicode. Considerare quindi il numero di caratteri e moltiplicare per 2.

• Per ogni blocco di metadati del contenitore BLOB archiviato, viene archiviata la lunghezza del nome (ASCII) più la lunghezza del valore della stringa.

• 512 byte per identificatore firmato include il nome dell'identificatore firmato, l'ora di inizio, l'ora di scadenza e le autorizzazioni.

BLOB

Nei calcoli seguenti viene illustrato come calcolare la quantità di spazio di archiviazione usato per ogni BLOB.

• BLOB in blocchi (BLOB di base o snapshot):

  124 bytes + Len(BlobName) * 2 bytes +
  For-Each Metadata[3 bytes + Len(MetadataName) + Len(Value)] +
  8 bytes + number of committed and uncommitted blocks * Block ID Size in bytes +
  SizeInBytes(data in unique committed data blocks stored) +
  SizeInBytes(data in uncommitted data blocks)
  

• BLOB di pagine (BLOB di base o snapshot):

  124 bytes + Len(BlobName) * 2 bytes +
  For-Each Metadata[3 bytes + Len(MetadataName) + Len(Value)] +
  number of nonconsecutive page ranges with data * 12 bytes +
  SizeInBytes(data in unique pages stored)
  

I dettagli sono indicati di seguito:

• 124 byte di sovraccarico per BLOB, che include:

  • Ora ultima modifica
  • Dimensione
  • Cache-Control
  • Content-Type
  • Content-Language
  • Content-Encoding
  • Content-MD5
  • Autorizzazioni
  • Informazioni sugli snapshot
  • Lease
  • Alcuni metadati del file system

• Il nome del BLOB viene archiviato come Unicode. Considerare quindi il numero di caratteri e moltiplicare per 2.

• Per ogni blocco di metadati archiviato aggiungere la lunghezza del nome (archiviato come ASCII) alla lunghezza del valore della stringa.

• Per i BLOB in blocchi:

  • 8 byte per l'elenco di blocchi.

  • Il numero di blocchi moltiplicato per le dimensioni dell'ID blocco in byte.

  • Le dimensioni dei dati in tutti blocchi con commit e senza commit.

    Nota

    Quando vengono usati gli snapshot, questa dimensione include solo i dati univoci per il BLOB di base o il BLOB snapshot. Se i blocchi senza commit non vengono usati dopo una settimana, sono sottoposto a Garbage Collection. In seguito non vengono considerati per la fatturazione.

• Per i BLOB di pagine:

  • Numero di intervalli di pagine non consecutivi con i dati per 12 byte. Questo è il numero di intervalli di pagine univoche visualizzato quando si chiama l'API GetPageRanges.

  • Le dimensioni dei dati in byte di tutte le pagine archiviate.

    Nota

    Quando vengono usati gli snapshot, questa dimensione include solo le pagine univoche per il BLOB di base o snapshot in fase di conteggio.

Script di esempio

# this script will show how to get the total size of the blobs in a container
# before running this, you need to create a storage account, create a container,
#    and upload some blobs into the container
# note: this retrieves all of the blobs in the container in one command.
#       connect Azure with Login-AzAccount before you run the script.
#       requests sent as part of this tool will incur transactional costs.
# command line usage: script.ps1 -ResourceGroup {YourResourceGroupName} -StorageAccountName {YourAccountName} -ContainerName {YourContainerName}
#

param(
    [Parameter(Mandatory=$true)]
    [string]$ResourceGroup,

    [Parameter(Mandatory=$true)]
    [string]$StorageAccountName,

    [Parameter(Mandatory=$true)]
    [string]$ContainerName
)

#Set-StrictMode will cause Get-AzStorageBlob returns result in different data types when there is only one blob
#Set-StrictMode -Version 2

$VerbosePreference = "Continue"

if((Get-Module -ListAvailable Az.Storage) -eq $null)
{
    throw "Azure Powershell not found! Please install from https://docs.microsoft.com/en-us/powershell/azure/install-Az-ps"
}

# function Retry-OnRequest
function Retry-OnRequest
{
    param(
        [Parameter(Mandatory=$true)]
        $Action)

    # It could encounter various of temporary errors, like network errors, or storage server busy errors.
    # Should retry the request on transient errors

    # Retry on storage server timeout errors
    $clientTimeOut = New-TimeSpan -Minutes 15
    $retryPolicy = New-Object -TypeName Microsoft.Azure.Storage.RetryPolicies.ExponentialRetry -ArgumentList @($clientTimeOut, 10)
    $requestOption = @{}
    $requestOption.RetryPolicy = $retryPolicy

    # Retry on temporary network errors
    $shouldRetryOnException = $false
    $maxRetryCountOnException = 3

    do
    {
        try
        {
            return $Action.Invoke($requestOption)
        }
        catch
        {
            if ($_.Exception.InnerException -ne $null -And $_.Exception.InnerException.GetType() -Eq [System.TimeoutException] -And $maxRetryCountOnException -gt 0)
            {
                $shouldRetryOnException = $true
                $maxRetryCountOnException--
            }
            else
            {
                $shouldRetryOnException = $false
                throw
            }
        }
    }
    while ($shouldRetryOnException)

}

# function Get-BlobBytes

function Get-BlobBytes
{
    param(
        [Parameter(Mandatory=$true)]
        $Blob,
        [Parameter(Mandatory=$false)]
        [bool]$IsPremiumAccount = $false)

    # Base + blobname
    $blobSizeInBytes = 124 + $Blob.Name.Length * 2

    # Get size of metadata
    $metadataEnumerator=$Blob.ICloudBlob.Metadata.GetEnumerator()
    while($metadataEnumerator.MoveNext())
    {
        $blobSizeInBytes += 3 + $metadataEnumerator.Current.Key.Length + $metadataEnumerator.Current.Value.Length
    }

    if (!$IsPremiumAccount)
    {
        if($Blob.BlobType -eq [Microsoft.Azure.Storage.Blob.BlobType]::BlockBlob)
        {
            $blobSizeInBytes += 8
            # Default is Microsoft.Azure.Storage.Blob.BlockListingFilter.Committed. Need All
            $action = { param($requestOption) return $Blob.ICloudBlob.DownloadBlockList([Microsoft.Azure.Storage.Blob.BlockListingFilter]::All, $null, $requestOption) }

            $blocks=Retry-OnRequest $action

            if ($null -eq $blocks)
            {
                $blobSizeInBytes += $Blob.ICloudBlob.Properties.Length
            }
            else
            {
                $blocks | ForEach-Object { $blobSizeInBytes += $_.Length + $_.Name.Length }
            }
        }
        elseif($Blob.BlobType -eq [Microsoft.Azure.Storage.Blob.BlobType]::PageBlob)
        {
            # It could cause server time out issue when trying to get page ranges of highly fragmented page blob
            # Get page ranges in segment can mitigate chance of meeting such kind of server time out issue
            # See https://blogs.msdn.microsoft.com/windowsazurestorage/2012/03/26/getting-the-page-ranges-of-a-large-page-blob-in-segments/ for details.
            $pageRangesSegSize = 148 * 1024 * 1024L
            $totalSize = $Blob.ICloudBlob.Properties.Length
            $pageRangeSegOffset = 0

            $pageRangesTemp = New-Object System.Collections.ArrayList

            while ($pageRangeSegOffset -lt $totalSize)
            {
                $action = {param($requestOption) return $Blob.ICloudBlob.GetPageRanges($pageRangeSegOffset, $pageRangesSegSize, $null, $requestOption) }

                Retry-OnRequest $action | ForEach-Object { $pageRangesTemp.Add($_) }  | Out-Null
                $pageRangeSegOffset += $pageRangesSegSize
            }

            $pageRanges = New-Object System.Collections.ArrayList

            foreach ($pageRange in $pageRangesTemp)
            {
                if($lastRange -eq $Null)
                {
                    $lastRange = New-Object PageRange
                    $lastRange.StartOffset = $pageRange.StartOffset
                    $lastRange.EndOffset =  $pageRange.EndOffset
                }
                else
                {
                    if (($lastRange.EndOffset + 1) -eq $pageRange.StartOffset)
                    {
                        $lastRange.EndOffset = $pageRange.EndOffset
                    }
                    else
                    {
                        $pageRanges.Add($lastRange)  | Out-Null
                        $lastRange = New-Object PageRange
                        $lastRange.StartOffset = $pageRange.StartOffset
                        $lastRange.EndOffset =  $pageRange.EndOffset
                    }
                }
            }

            $pageRanges.Add($lastRange) | Out-Null
            $pageRanges |  ForEach-Object {
                    $blobSizeInBytes += 12 + $_.EndOffset - $_.StartOffset
                }
        }
        else
        {
            $blobSizeInBytes += $Blob.ICloudBlob.Properties.Length
        }
        return $blobSizeInBytes
    }
    else
    {
        $blobSizeInBytes += $Blob.ICloudBlob.Properties.Length
    }
    return $blobSizeInBytes
}

# function Get-ContainerBytes

function Get-ContainerBytes
{
    param(
        [Parameter(Mandatory=$true)]
        [Microsoft.Azure.Storage.Blob.CloudBlobContainer]$Container,
        [Parameter(Mandatory=$false)]
        [bool]$IsPremiumAccount = $false)

    # Base + name of container
    $containerSizeInBytes = 48 + $Container.Name.Length*2

    # Get size of metadata
    $metadataEnumerator = $Container.Metadata.GetEnumerator()
    while($metadataEnumerator.MoveNext())
    {
        $containerSizeInBytes += 3 + $metadataEnumerator.Current.Key.Length + $metadataEnumerator.Current.Value.Length
    }

    # Get size for SharedAccessPolicies
    $containerSizeInBytes += $Container.GetPermissions().SharedAccessPolicies.Count * 512

    # Calculate size of all blobs.
    $blobCount = 0
    $Token = $Null
    $MaxReturn = 5000

    do {
        $Blobs = Get-AzStorageBlob -Context $storageContext -Container $Container.Name -MaxCount $MaxReturn -ContinuationToken $Token
        if($Blobs -eq $Null) { break }

        #Set-StrictMode will cause Get-AzStorageBlob returns result in different data types when there is only one blob
        if($Blobs.GetType().Name -eq "AzureStorageBlob")
        {
            $Token = $Null
        }
        else
        {
            $Token = $Blobs[$Blobs.Count - 1].ContinuationToken;
        }

        $Blobs | ForEach-Object {
                $blobSize = Get-BlobBytes $_ $IsPremiumAccount
                $containerSizeInBytes += $blobSize
                $blobCount++

                if(($blobCount % 1000) -eq 0)
                {
                    Write-Verbose("Counting {0} Sizing {1} " -f $blobCount, $containerSizeInBytes)
                }
            }
    }
    While ($Token -ne $Null)

    return @{ "containerSize" = $containerSizeInBytes; "blobCount" = $blobCount }
}

#Login-AzAccount

$storageAccount = Get-AzStorageAccount -ResourceGroupName $ResourceGroup -Name $StorageAccountName -ErrorAction SilentlyContinue
if($storageAccount -eq $null)
{
    throw "The storage account specified does not exist in this subscription."
}

$storageContext = $storageAccount.Context

if (-not ([System.Management.Automation.PSTypeName]'PageRange').Type)
{
    $Source = "
        public class PageRange
        {
            public long StartOffset;
            public long EndOffset;
        }"
    Add-Type -TypeDefinition $Source
}

$containers = New-Object System.Collections.ArrayList
if($ContainerName.Length -ne 0)
{
    $container = Get-AzStorageContainer -Context $storageContext -Name $ContainerName -ErrorAction SilentlyContinue |
        ForEach-Object { $containers.Add($_) } | Out-Null
}
else
{
    Get-AzStorageContainer -Context $storageContext | ForEach-Object { $containers.Add($_) } | Out-Null
}

$sizeInBytes = 0
$IsPremiumAccount = ($storageAccount.Sku.Tier -eq "Premium")

if($containers.Count -gt 0)
{
    $containers | ForEach-Object {
        Write-Output("Calculating container {0} ..." -f $_.CloudBlobContainer.Name)
        $result = Get-ContainerBytes $_.CloudBlobContainer $IsPremiumAccount
        $sizeInBytes += $result.containerSize

        Write-Output("Container '{0}' with {1} blobs has a sizeof {2:F2} MB." -f $_.CloudBlobContainer.Name,$result.blobCount,($result.containerSize/1MB))
    }
}
else
{
    Write-Warning "No containers found to process in storage account '$StorageAccountName'."
}

Passaggi successivi

• Vedere l'articolo su come calcolare le dimensioni totali di un contenitore di archiviazione BLOB per un semplice script che offre una stima delle dimensioni del contenitore.

• Per altre informazioni sulla fatturazione dell'Archiviazione di Azure, vedere Informazioni sulla fatturazione dell'Archiviazione di Microsoft Azure.

• Per altre informazioni sul modulo Azure PowerShell, vedere la documentazione di Azure PowerShell.

• Sono disponibili altri esempi di script di archiviazione di PowerShell in PowerShell samples for Azure Blob storage (Esempi di PowerShell per Archiviazione di Azure).