Cálculo del tamaño total de facturación de un contenedor de blobs
Este script calcula el tamaño de un contenedor de Azure Blob Storage con la finalidad de estimar los costos de facturación. El script suma el total de los tamaños de los blobs del contenedor.
Importante
El script de ejemplo que se proporciona en este artículo podría no calcular con precisión el tamaño de facturación de las instantáneas de blob.
Este ejemplo requiere Azure PowerShell. Ejecute Get-Module -ListAvailable Az para encontrar la versión.
Si necesita instalarla o actualizarla, consulte el artículo sobre cómo instalar el módulo de Azure PowerShell.
Ejecute el cmdlet Connect-AzAccount para conectarse a Azure.
Si no tiene una suscripción a Azure, cree una cuenta gratuita de Azure antes de empezar.
Nota:
Este script de PowerShell calcula el tamaño de un contenedor a efectos de facturación. Si va a calcular el tamaño de un contenedor para otros fines, consulte Cálculo del tamaño total de un contenedor de Blob Storage para obtener un script más sencillo que proporcione una estimación.
Determinación del tamaño de un contenedor de blobs
El tamaño total de un contenedor de blobs incluye el tamaño del contenedor y el tamaño de todos los blobs del contenedor.
En las secciones siguientes se describe cómo se calcula la capacidad de almacenamiento de los blobs y los contenedores de blobs. En la sección siguiente, Len(X) hace referencia al número de caracteres de la cadena.
Contenedores de blobs
En el siguiente cálculo se describe cómo calcular la cantidad de almacenamiento utilizado por cada contenedor de blobs:
48 bytes + Len(ContainerName) * 2 bytes +
For-Each Metadata[3 bytes + Len(MetadataName) + Len(Value)] +
For-Each Signed Identifier[512 bytes]
A continuación, se explica con detalle:
En los 48 bytes de sobrecarga para cada contenedor se incluye la hora de la última modificación, los permisos, la configuración públicos y algunos metadatos del sistema.
El nombre del contenedor se almacena como Unicode, por lo que se toma el número de caracteres y se multiplica por dos.
Para cada bloque de metadatos almacenado del contenedor de blobs, se almacena la longitud del nombre (ASCII), así como la longitud del valor de cadena.
En los 512 bytes por identificador firmado se incluyen el nombre del identificador firmado, la hora de inicio, la hora de expiración y los permisos.
Datos BLOB
En los cálculos siguientes se muestra cómo calcular la cantidad de almacenamiento usado por blob.
Blob en bloques (blob base o instantánea):
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 en páginas (blob base o instantánea):
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)
A continuación, se explica con detalle:
124 bytes de sobrecarga del blob, que incluye:
- Hora de la última modificación
- Size
- Cache-Control
- Content-Type
- Content-Language
- Content-Encoding
- Content-MD5
- Permisos
- Información de la instantánea
- Concesión
- Algunos metadatos del sistema
El nombre del blob se almacena como Unicode, por lo que se toma el número de caracteres y se multiplica por dos.
Para cada bloque de metadatos almacenado, agregue la longitud del nombre (guardado como ASCII), así como la longitud del valor de cadena.
Para los blobs en bloques:
8 bytes para la lista de bloques.
El número de bloques multiplicado por el tamaño del identificador de bloque en bytes.
El tamaño de los datos de todos los bloques confirmados y sin confirmar.
Nota:
Cuando se usan instantáneas, este tamaño solo incluye los datos únicos de este blob base o de instantánea. Si no se utilizan los bloques sin confirmar después de una semana, se recolectan como elementos no utilizados. Después de eso, no cuentan para la facturación.
Para los blobs en páginas:
El número de intervalos de páginas no consecutivas con datos multiplicado por 12 bytes. Este es el número de intervalos de páginas únicas que se ven al llamar a la API GetPageRanges.
El tamaño de los datos en bytes de todas las páginas almacenadas.
Nota:
Cuando se usan instantáneas, este tamaño solo incluye las páginas únicas del blob base o de instantánea que se cuenta.
Script de ejemplo
# 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'."
}
Pasos siguientes
Consulte Cálculo del tamaño total de un contenedor de Blob Storage para obtener un script sencillo que proporciona una estimación del tamaño del contenedor.
Para más información sobre la facturación de Azure Storage, vea la descripción de la facturación de Microsoft Azure Storage.
Para más información sobre el módulo de Azure PowerShell, consulte la documentación de Azure PowerShell.
Puede encontrar ejemplos de script adicionales de PowerShell para Storage en los ejemplos de PowerShell para Azure Storage.