Come posso ottenere le dimensioni di un bucket Amazon S3?

Vorrei rappresentare graficamente la dimensione (in byte e il numero di elementi) di un bucket Amazon S3 e sto cercando un modo efficiente per ottenere i dati.

Gli strumenti s3cmd forniscono un modo per ottenere la dimensione totale del file utilizzando s3cmd du s3://bucket_name, ma sono preoccupato per la sua capacità di ridimensionamento poiché sembra che recuperi i dati su ogni file e calcoli la propria somma. Poiché Amazon addebita gli utenti in GB-Mesi, sembra strano che non espongano direttamente questo valore.

Sebbene l'API REST di Amazon restituisca il numero di elementi in un bucket, s3cmd non sembra esporlo. Potrei farlo, s3cmd ls -r s3://bucket_name | wc -lma sembra un trucco.

La libreria Ruby AWS :: S3 sembrava promettente, ma fornisce solo il numero di articoli bucket, non la dimensione totale del bucket.

Qualcuno è a conoscenza di altri strumenti o librerie della riga di comando (preferisci Perl, PHP, Python o Ruby) che forniscono modi per ottenere questi dati?

La CLI AWS ora supporta il --queryparametro che accetta espressioni JMESPath .

Questo significa che puoi sommare i valori delle dimensioni dati list-objectsusando sum(Contents[].Size)e contando come length(Contents[]).

Questo può essere eseguito utilizzando l'interfaccia della riga di comando AWS ufficiale come di seguito ed è stato introdotto nel febbraio 2014

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

Questo ora può essere fatto in modo banale solo con il client ufficiale della riga di comando AWS:

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

Documentazione ufficiale

Ciò accetta anche prefissi di percorso se non si desidera contare l'intero bucket:

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

Console AWS:

A partire dal 28 luglio 2015 è possibile ottenere queste informazioni tramite CloudWatch . Se desideri una GUI, vai alla console di CloudWatch : (Scegli regione>) Metriche> S3

Comando CLI AWS:

Questo è molto più veloce di alcuni degli altri comandi pubblicati qui, in quanto non esegue una query sulla dimensione di ciascun file singolarmente per calcolare la somma.

 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 : è necessario specificare sia StorageType che BucketName nell'argomento dimensioni, altrimenti non si otterranno risultati. Tutto quello che devi cambiare è la --start-date, --end-timee Value=toukakoukan.com.

Ecco uno script bash che puoi usare per evitare di doverlo specificare --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

s3cmd può fare questo:

s3cmd du s3://bucket-name

Se scarichi un rapporto sull'utilizzo , puoi rappresentare graficamente i valori giornalieri per il TimedStorage-ByteHrscampo.

Se vuoi quel numero in GiB, dividi semplicemente per 1024 * 1024 * 1024 * 24(cioè GiB-ore per un ciclo di 24 ore). Se vuoi il numero in byte, dividi solo per 24 e traccia il grafico.

Utilizzando gli strumenti ufficiali della riga di comando di AWS s3:

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

Questo è un comando migliore, basta aggiungere i seguenti 3 parametri --summarize --human-readable --recursivedopo aws s3 ls. --summarizenon è richiesto, anche se dà un bel tocco sulla dimensione totale.

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

s4cmd è il modo più veloce che ho trovato (un'utilità da riga di comando scritta in Python):

pip install s4cmd

Ora per calcolare l'intera dimensione della benna utilizzando più thread:

s4cmd du -r s3://bucket-name

Ho usato l' API REST / Curl S3 elencata in precedenza in questo thread e ho fatto questo:

<?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';
?>

È possibile utilizzare l'utilità s3cmd, ad esempio:

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

Quindi, trollando attraverso l'API e riproducendo alcune stesse query, S3 produrrà l'intero contenuto di un bucket in una richiesta e non dovrà scendere nelle directory. I risultati quindi richiedono solo il riepilogo attraverso i vari elementi XML e non le chiamate ripetute. Non ho un bucket di campionamento che contenga migliaia di articoli, quindi non so quanto si ridimensionerà, ma sembra ragionevolmente semplice.

... Un po 'in ritardo, ma il modo migliore che ho trovato è usare i rapporti nel portale AWS. Ho creato una classe PHP per il download e l'analisi dei report. Con esso puoi ottenere il numero totale di oggetti per ogni bucket, dimensione totale in GB o ore byte e altro.

Dai un'occhiata e fammi sapere se è stato utile

AmazonTools

Ti consiglio di utilizzare il Rapporto di utilizzo S3 per i bucket di grandi dimensioni , vedi il mio How To su come ottenerlo Fondamentalmente devi scaricare il Rapporto di utilizzo per il servizio S3 per l'ultimo giorno con Archiviazione a tempo - Byte Hrs e analizzarlo per ottenere l'utilizzo del disco.

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

La documentazione di AWS spiega come farlo:

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

Questo è l'output che ottieni:

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

Per un approccio davvero a bassa tecnologia: usa un client S3 in grado di calcolare le dimensioni per te. Sto usando Panic's Transmit, fare clic su un bucket, fare "Ottieni informazioni" e fare clic sul pulsante "Calcola". Non sono sicuro di quanto sia veloce o preciso rispetto ad altri metodi, ma sembra restituire la dimensione che mi aspettavo fosse.

Dato che ci sono così tante risposte, ho pensato di presentare la mia. Ho scritto la mia implementazione in C # usando LINQPad. Copia, incolla e inserisci la chiave di accesso, la chiave segreta, l'endpoint della regione e il nome del bucket che desideri interrogare. Inoltre, assicurati di aggiungere il pacchetto nuget AWSSDK.

Provando contro uno dei miei secchi, mi ha dato un conteggio di 128075 e una dimensione di 70,6 GB. So che è preciso al 99,9999%, quindi sono bravo con il risultato.

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 vuoi ottenere le dimensioni dalla Console AWS:

1. Vai su S3 e fai clic sul nome del bucket
2. Seleziona la scheda "Gestione"

3. Seleziona la scheda Metriche

Per impostazione predefinita, dovresti vedere la metrica di archiviazione del bucket

So che questa è una domanda precedente, ma ecco un esempio di PowerShell:

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

$A contiene la dimensione del bucket e esiste un parametro keyname se si desidera solo la dimensione di una cartella specifica in un bucket.

Per controllare tutte le dimensioni dei bucket, prova questo 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

Puoi usare s3cmd:

s3cmd du s3://Mybucket -H

o

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

Fornisce gli oggetti totali e le dimensioni del secchio in una forma molto leggibile.

Ehi, esiste uno strumento di ricerca dei metadati per AWS S3 su https://s3search.p3-labs.com/ . Questo strumento fornisce statistiche sugli oggetti in un bucket con la ricerca sui metadati.

Anche Hanzo S3 Tools fa questo. Una volta installato, puoi fare:

s3ls -s -H bucketname

Ma credo che questo sia anche sommato sul lato client e non recuperato tramite l'API AWS.

Tramite il programma Cloudberry è anche possibile elencare la dimensione del bucket, la quantità di cartelle e i file totali, facendo clic su "proprietà" proprio nella parte superiore del bucket.

Se non si desidera utilizzare la riga di comando, su Windows e OSX, esiste un'app per la gestione dei file remoti per scopi generici chiamata Cyberduck . Accedi a S3 con la tua coppia di chiavi di accesso / segrete, fai clic con il pulsante destro del mouse sulla directory, fai clic Calculate.

Ho scritto uno script Bash, s3-du.sh che elencherà i file nel bucket con s3ls e stamperà il conteggio dei file e dimensioni come

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    

Fa la dimensione della sottodirectory, poiché Amazon restituisce il nome della directory e la dimensione di tutto il suo contenuto.

CloudWatch ha ora un dashboard di servizio S3 predefinito che lo elenca in un grafico chiamato "Dimensione media bucket". Penso che questo link funzionerà per chiunque abbia già effettuato l'accesso alla Console AWS:

Il modo seguente utilizza AWS PHP SDK per ottenere la dimensione totale del 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;

Questo funziona per me ..

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