Como posso obter o tamanho de um bucket do Amazon S3?

Gostaria de representar graficamente o tamanho (em bytes e número de itens) de um bucket do Amazon S3 e estou procurando uma maneira eficiente de obter os dados.

As ferramentas s3cmd fornecem uma maneira de obter o tamanho total do arquivo s3cmd du s3://bucket_name, mas estou preocupado com sua capacidade de escalar, pois parece que ele busca dados sobre cada arquivo e calcula sua própria soma. Como a Amazon cobra usuários em GB-meses, parece estranho que eles não exponham esse valor diretamente.

Embora a API REST da Amazon retorne o número de itens em um bucket, o s3cmd não parece expô-lo. Eu poderia fazer, s3cmd ls -r s3://bucket_name | wc -lmas isso parece um hack.

A biblioteca Ruby AWS :: S3 parecia promissora, mas fornece apenas o número de itens do balde, não o tamanho total do balde.

Alguém conhece outras ferramentas ou bibliotecas de linha de comando (prefere Perl, PHP, Python ou Ruby) que fornecem maneiras de obter esses dados?

A CLI da AWS agora suporta o --queryparâmetro que aceita expressões JMESPath .

Isso significa que você pode somar os valores de tamanho fornecidos list-objectsusando sum(Contents[].Size)e contar como length(Contents[]).

Isso pode ser executado usando a CLI oficial da AWS como abaixo e foi introduzido em fevereiro de 2014

 aws s3api list-objects --bucket BUCKETNAME --output json --query "[sum(Contents[].Size), length(Contents[])]"

Agora isso pode ser feito trivialmente apenas com o cliente oficial da linha de comando da AWS:

aws s3 ls --summarize --human-readable --recursive s3://bucket-name/

Documentação oficial

Isso também aceita prefixos de caminho se você não quiser contar todo o intervalo:

aws s3 ls --summarize --human-readable --recursive s3://bucket-name/directory

Console da AWS:

A partir de 28 de julho de 2015, você poderá obter essas informações via CloudWatch . Se você deseja uma GUI, acesse o console do CloudWatch : (Escolha Região>) Métricas> S3

Comando da CLI da AWS:

Isso é muito mais rápido que alguns dos outros comandos publicados aqui, pois não consulta o tamanho de cada arquivo individualmente para calcular a soma.

 aws cloudwatch get-metric-statistics --namespace AWS/S3 --start-time 2015-07-15T10:00:00 --end-time 2015-07-31T01:00:00 --period 86400 --statistics Average --region eu-west-1 --metric-name BucketSizeBytes --dimensions Name=BucketName,Value=toukakoukan.com Name=StorageType,Value=StandardStorage

Importante : Você deve especificar StorageType e BucketName no argumento de dimensões, caso contrário você não obterá resultados. Tudo que você precisa mudar é a --start-date, --end-time, e Value=toukakoukan.com.

Aqui está um script que você pode usar para evitar ter de especificar --start-datee --end-timemanualmente.

#!/bin/bash
bucket=$1
region=$2
now=$(date +%s)
aws cloudwatch get-metric-statistics --namespace AWS/S3 --start-time "$(echo "$now - 86400" | bc)" --end-time "$now" --period 86400 --statistics Average --region $region --metric-name BucketSizeBytes --dimensions Name=BucketName,Value="$bucket" Name=StorageType,Value=StandardStorage

O s3cmd pode fazer isso:

s3cmd du s3://bucket-name

Se você baixar um relatório de uso , poderá representar graficamente os valores diários para o TimedStorage-ByteHrscampo.

Se você quiser esse número no GiB, apenas divida por 1024 * 1024 * 1024 * 24(isso é GiB-horas para um ciclo de 24 horas). Se você quiser o número em bytes, apenas divida por 24 e faça um gráfico.

Usando as ferramentas de linha de comando oficiais do AWS s3:

aws s3 ls s3://bucket/folder --recursive | awk 'BEGIN {total=0}{total+=$3}END{print total/1024/1024" MB"}'

Este é um comando melhor, basta adicionar os 3 parâmetros a --summarize --human-readable --recursiveseguir aws s3 ls. --summarizenão é necessário, mas fornece um toque agradável no tamanho total.

aws s3 ls s3://bucket/folder --summarize --human-readable --recursive

s4cmd é a maneira mais rápida que eu encontrei (um utilitário de linha de comando escrito em Python):

pip install s4cmd

Agora, para calcular o tamanho inteiro do balde usando vários segmentos:

s4cmd du -r s3://bucket-name

Eu usei a API REST / Curl S3 listada anteriormente neste segmento e fiz isso:

<?php
if (!class_exists('S3')) require_once 'S3.php';

// Instantiate the class
$s3 = new S3('accessKeyId', 'secretAccessKey');
S3::$useSSL = false;

// List your buckets:
echo "S3::listBuckets(): ";
echo '<pre>' . print_r($s3->listBuckets(), 1). '</pre>';

$totalSize = 0;
$objects = $s3->getBucket('name-of-your-bucket');
foreach ($objects as $name => $val) {
    // If you want to get the size of a particular directory, you can do
    // only that.
    // if (strpos($name, 'directory/sub-directory') !== false)
    $totalSize += $val['size'];
}

echo ($totalSize / 1024 / 1024 / 1024) . ' GB';
?>

Você pode usar o utilitário s3cmd, por exemplo:

s3cmd du -H s3://Mybucket
97G      s3://Mybucket/

Assim, percorrendo a API e reproduzindo as mesmas consultas, o S3 produzirá todo o conteúdo de um bucket em uma solicitação e não precisará descer para diretórios. Os resultados exigem apenas a soma dos vários elementos XML, e não as chamadas repetidas. Eu não tenho um balde de amostra com milhares de itens, então não sei o quão bem ele será dimensionado, mas parece razoavelmente simples.

... Um pouco tarde, mas a melhor maneira que encontrei é usando os relatórios no portal da AWS. Fiz uma aula de PHP para baixar e analisar os relatórios. Com ele, você pode obter o número total de objetos para cada bloco, tamanho total em GB ou byte hrs e muito mais.

Confira e deixe-me saber se foi útil

AmazonTools

Eu recomendo usar o Relatório de uso do S3 para baldes grandes , consulte o meu Como fazer. Como fazer o download Basicamente, você precisa fazer o download do serviço Relatório de uso do S3 do último dia com Timed Storage - Byte Hrs e analisá-lo para obter o uso do disco.

cat report.csv | awk -F, '{printf "%.2f GB %s %s \n", $7/(1024**3 )/24, $4, $2}' | sort -n

A documentação da AWS informa como fazê-lo:

aws s3 ls s3://bucketnanme --recursive --human-readable --summarize

Esta é a saída que você obtém:

2016-05-17 00:28:14    0 Bytes folder/
2016-05-17 00:30:57    4.7 KiB folder/file.jpg
2016-05-17 00:31:00  108.9 KiB folder/file.png
2016-05-17 00:31:03   43.2 KiB folder/file.jpg
2016-05-17 00:31:08  158.6 KiB folder/file.jpg
2016-05-17 00:31:12   70.6 KiB folder/file.png
2016-05-17 00:43:50   64.1 KiB folder/folder/folder/folder/file.jpg

Total Objects: 7

   Total Size: 450.1 KiB

Para uma abordagem realmente de baixa tecnologia: use um cliente S3 que possa calcular o tamanho para você. Estou usando o Panic's Transmit, clique em um balde, faça "Obter informações" e clique no botão "Calcular". Não tenho certeza de quão rápido ou preciso é em relação a outros métodos, mas parece devolver o tamanho que eu esperava.

Como existem tantas respostas, achei que participaria da minha própria. Eu escrevi minha implementação em c # usando o LINQPad. Copie, cole e insira a chave de acesso, chave secreta, terminal da região e nome do bloco que deseja consultar. Além disso, certifique-se de adicionar o pacote de nuget do AWSSDK.

Testando contra um dos meus baldes, me deu uma contagem de 128075 e um tamanho de 70,6 GB. Eu sei que é 99,9999% exato, então estou bem com o resultado.

void Main() {
    var s3Client = new AmazonS3Client("accessKey", "secretKey", RegionEndpoint.???);
    var stop = false;
    var objectsCount = 0;
    var objectsSize = 0L;
    var nextMarker = string.Empty;

    while (!stop) {
        var response = s3Client.ListObjects(new ListObjectsRequest {
            BucketName = "",
            Marker = nextMarker
        });

        objectsCount += response.S3Objects.Count;
        objectsSize += response.S3Objects.Sum(
            o =>
                o.Size);
        nextMarker = response.NextMarker;
        stop = response.S3Objects.Count < 1000;
    }

    new {
        Count = objectsCount,
        Size = objectsSize.BytesToString()
    }.Dump();
}

static class Int64Extensions {
    public static string BytesToString(
        this long byteCount) {
        if (byteCount == 0) {
            return "0B";
        }

        var suffix = new string[] { "B", "KB", "MB", "GB", "TB", "PB", "EB" };
        var longBytes = Math.Abs(byteCount);
        var place = Convert.ToInt32(Math.Floor(Math.Log(longBytes, 1024)));
        var number = Math.Round(longBytes / Math.Pow(1024, place), 1);

        return string.Format("{0}{1}", Math.Sign(byteCount) * number, suffix[place]);
    }
}

Se você deseja obter o tamanho do AWS Console:

1. Vá para S3 e clique no nome do bucket
2. Selecione a guia "Gerenciamento"

3. Selecione a guia Métricas

Por padrão, você deve ver Métrica de Armazenamento do bucket

Sei que essa é uma pergunta mais antiga, mas aqui está um exemplo do PowerShell:

Get-S3Object -BucketName <buckename> | select key, size | foreach {$A += $_.size}

$A contém o tamanho do bucket e existe um parâmetro keyname se você deseja apenas o tamanho de uma pasta específica em um bucket.

Para verificar o tamanho de todos os buckets, tente este script bash

s3list=`aws s3 ls | awk  '{print $3}'`
for s3dir in $s3list
do
    echo $s3dir
    aws s3 ls "s3://$s3dir"  --recursive --human-readable --summarize | grep "Total Size"
done

Você pode usar s3cmd:

s3cmd du s3://Mybucket -H

ou

s3cmd du s3://Mybucket --human-readable

Ele fornece o total de objetos e o tamanho do balde de uma forma muito legível.

Olá, existe uma ferramenta de pesquisa de metadados para o AWS S3 em https://s3search.p3-labs.com/ . Essa ferramenta fornece estatísticas sobre objetos em um bucket com pesquisa em metadados.

O Hanzo S3 Tools também faz isso. Depois de instalado, você pode:

s3ls -s -H bucketname

Mas acredito que isso também é resumido no lado do cliente e não é recuperado pela API da AWS.

Pelo programa Cloudberry também é possível listar o tamanho do balde, a quantidade de pastas e o total de arquivos, clicando em "propriedades" logo em cima do balde.

Se você não quiser usar a linha de comando, no Windows e no OSX, existe um aplicativo de gerenciamento remoto de arquivos de uso geral chamado Cyberduck . Entre no S3 com seu par de chaves secretas / de acesso, clique com o botão direito do mouse no diretório e clique em Calculate.

Eu escrevi um script Bash, s3-du.sh, que lista os arquivos no bucket com s3ls e imprime a contagem de arquivos e tamanhos como

s3-du.sh testbucket.jonzobrist.com
149 files in bucket testbucket.jonzobrist.com
11760850920 B
11485205 KB
11216 MB
10 GB

Script completo:

#!/bin/bash

if [ “${1}” ]
then
NUM=0
COUNT=0
for N in `s3ls ${1} | awk ‘{print $11}’ | grep [0-9]`
do
NUM=`expr $NUM + $N`
((COUNT++))
done
KB=`expr ${NUM} / 1024`
MB=`expr ${NUM} / 1048576`
GB=`expr ${NUM} / 1073741824`
echo “${COUNT} files in bucket ${1}”
echo “${NUM} B”
echo “${KB} KB”
echo “${MB} MB”
echo “${GB} GB”
else
echo “Usage : ${0} s3-bucket”
exit 1
fi    

Ele faz o tamanho do subdiretório, pois a Amazon retorna o nome do diretório e o tamanho de todo o seu conteúdo.

O CloudWatch agora possui um painel de serviço S3 padrão, que o lista em um gráfico chamado "Média de bytes de tamanho do balde". Acho que esse link funcionará para qualquer um que já esteja conectado ao AWS Console:

A maneira a seguir usa o AWS PHP SDK para obter o tamanho total do bucket.

// make sure that you are using correct region (where the bucket is) to get new Amazon S3 client
$client = \Aws\S3\S3Client::factory(array('region' => $region));

// check if bucket exists
if (!$client->doesBucketExist($bucket, $accept403 = true)) {
    return false;
}
// get bucket objects
$objects = $client->getBucket(array('Bucket' => $bucket));

$total_size_bytes = 0;
$contents = $objects['Contents'];

// iterate through all contents to get total size
foreach ($contents as $key => $value) {
   $total_bytes += $value['Size'];
}
$total_size_gb = $total_size_bytes / 1024 / 1024 / 1024;

Isso funciona para mim ..

aws s3 ls s3://bucket/folder/ --recursive | awk '{sz+=$3} END {print sz/1024/1024 "MB"}'