Comment obtenir la taille d'un compartiment Amazon S3?

J'aimerais représenter graphiquement la taille (en octets et nombre d'éléments) d'un compartiment Amazon S3 et je recherche un moyen efficace d'obtenir les données.

Les outils s3cmd fournissent un moyen d'obtenir la taille totale du fichier s3cmd du s3://bucket_name, mais je suis inquiet quant à sa capacité à évoluer, car il semblerait qu'il récupère les données de chaque fichier et calcule sa propre somme. Étant donné qu'Amazon facture ses utilisateurs en Go-Mois, il semble étrange qu'ils n'exposent pas cette valeur directement.

Bien que l'API REST d'Amazon renvoie le nombre d'éléments dans un compartiment , s3cmd ne semble pas l'exposer. Je pourrais le faire, s3cmd ls -r s3://bucket_name | wc -lmais cela semble être un bidouillage.

La bibliothèque Ruby AWS :: S3 semblait prometteuse, mais ne fournit que le nombre d'éléments de compartiment, pas la taille totale du compartiment.

Est-ce que quelqu'un connaît d'autres outils ou bibliothèques en ligne de commande (préférez Perl, PHP, Python ou Ruby) qui fournissent des moyens d'obtenir ces données?

AWS CLI prend désormais en charge le --queryparamètre qui prend une expression JMESPath .

Cela signifie que vous pouvez additionner les valeurs de taille données en list-objectsutilisant sum(Contents[].Size)et compter comme length(Contents[]).

Ceci peut être exécuté à l'aide de l'AWS CLI officiel, comme ci-dessous, et a été introduit en février 2014.

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

Cela peut maintenant être fait de manière triviale avec seulement le client de ligne de commande AWS officiel:

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

Documentation officielle

Cela accepte également les préfixes de chemin si vous ne voulez pas compter le compartiment entier:

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

AWS Console:

En date du 28 de Juillet ici à 2015 , vous pouvez obtenir ces informations via CloudWatch . Si vous souhaitez une interface graphique, accédez à la console CloudWatch : (Choisissez une région>)> Métriques> S3

Commande AWS CLI:

Ceci est beaucoup plus rapide que certaines des autres commandes publiées ici, car il ne demande pas la taille de chaque fichier individuellement pour calculer la somme.

 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

Important : Vous devez spécifier StorageType et BucketName dans l'argument de dimensions, sinon vous n'obtiendrez aucun résultat. Tout ce que vous devez changer est la --start-date, --end-timeet Value=toukakoukan.com.

Voici un script bash que vous pouvez utiliser pour éviter de devoir spécifier --start-dateet --end-timemanuellement.

#!/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 peut faire ceci:

s3cmd du s3://bucket-name

Si vous téléchargez un rapport d'utilisation , vous pouvez représenter graphiquement les valeurs quotidiennes du TimedStorage-ByteHrschamp.

Si vous voulez ce nombre en Gio, divisez simplement par 1024 * 1024 * 1024 * 24(c'est Gio-heure pour un cycle de 24 heures). Si vous voulez le nombre en octets, il suffit de diviser par 24 et de tracer le graphique.

Utilisation des outils de ligne de commande AWS s3 officiels:

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

C'est une meilleure commande, il suffit d'ajouter les 3 paramètres suivants --summarize --human-readable --recursiveaprès aws s3 ls. --summarizen'est pas obligatoire, mais donne une bonne idée de la taille totale.

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

s4cmd est le moyen le plus rapide que j'ai trouvé (un utilitaire de ligne de commande écrit en Python):

pip install s4cmd

Maintenant, calculons la taille totale du compartiment en utilisant plusieurs threads:

s4cmd du -r s3://bucket-name

J'ai utilisé l' API S3 REST / Curl répertoriée plus haut dans ce fil de discussion:

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

Vous pouvez utiliser l'utilitaire s3cmd, par exemple:

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

Alors, parcourant l'API et jouant à plusieurs requêtes identiques, S3 produira le contenu complet d'un compartiment en une seule requête et il n'aura pas besoin de descendre dans des répertoires. Les résultats nécessitent alors simplement de faire la somme des différents éléments XML et non des appels répétés. Je n'ai pas d'échantillons contenant des milliers d'articles, alors je ne sais pas dans quelle mesure il va évoluer, mais cela semble assez simple.

... Un peu tard, mais le meilleur moyen que j'ai trouvé est d'utiliser les rapports du portail AWS. J'ai créé une classe PHP pour le téléchargement et l'analyse des rapports. Avec cela, vous pouvez obtenir le nombre total d'objets pour chaque compartiment, la taille totale en Go ou en octets et plus.

Check it out et laissez-moi savoir si était utile

AmazonTools

Je recommande d'utiliser le rapport d'utilisation S3 pour les grands compartiments. Pour plus d'informations , reportez- vous à la section Comment l' obtenir. Vous devez essentiellement télécharger le rapport d'utilisation du service S3 pour le dernier jour avec Stockage synchronisé - Octets heures et l'analyser pour obtenir l'utilisation du disque.

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

La documentation AWS vous explique comment procéder:

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

Voici le résultat obtenu:

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

Pour une approche vraiment low-tech: utilisez un client S3 capable de calculer la taille pour vous. J'utilise Panic's Transmit, cliquez sur un seau, faites "Obtenir des informations" et cliquez sur le bouton "Calculer". Je ne suis pas sûr de sa rapidité ni de sa précision par rapport à d'autres méthodes, mais cela semble redonner la taille à laquelle je m'attendais.

Puisqu'il y a tant de réponses, j'ai pensé que j'allais ajouter les miennes. J'ai écrit mon implémentation en C # en utilisant LINQPad. Copiez, collez et entrez la clé d'accès, la clé secrète, le point de terminaison de la région et le nom du compartiment que vous souhaitez interroger. Assurez-vous également d'ajouter le package de nuget AWSSDK.

En testant contre un de mes seaux, il m'a donné un compte de 128075 et une taille de 70,6 Go. Je sais que la précision est de 99,9999%, alors je suis bon avec le résultat.

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]);
    }
}

Si vous souhaitez obtenir la taille de la console AWS:

1. Allez à S3 et cliquez sur le nom du seau
2. Sélectionnez l'onglet "Management"

3. Sélectionnez l' onglet Métriques

Par défaut, vous devriez voir la métrique de stockage du compartiment.

Je sais que c'est une question plus ancienne, mais voici un exemple de PowerShell:

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

$A contient la taille du compartiment, et il existe un paramètre keyname si vous souhaitez uniquement la taille d'un dossier spécifique dans un compartiment.

Pour vérifier toutes les tailles de seaux, essayez ce 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

Vous pouvez utiliser s3cmd:

s3cmd du s3://Mybucket -H

ou

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

Il donne le nombre total d'objets et la taille du seau sous une forme très lisible.

Il existe un outil de recherche de métadonnées pour AWS S3 à l’ adresse https://s3search.p3-labs.com/ . Cet outil fournit des statistiques sur les objets dans un compartiment avec une recherche sur des métadonnées.

C'est également ce que fait Hanzo S3 Tools . Une fois installé, vous pouvez faire:

s3ls -s -H bucketname

Mais je pense que cela est également résumé du côté client et n'est pas récupéré via l'API AWS.

Par Cloudberry , il est également possible de lister la taille du compartiment, le nombre de dossiers et le nombre total de fichiers, en cliquant sur "propriétés" juste en haut du compartiment.

Si vous ne souhaitez pas utiliser la ligne de commande, sous Windows et OSX, il existe une application de gestion de fichiers à distance polyvalente appelée Cyberduck . Connectez-vous à S3 avec votre paire clé d'accès / clé secrète, cliquez avec le bouton droit sur le répertoire, cliquez sur Calculate.

J'ai écrit un script Bash, s3-du.sh, qui répertorie les fichiers dans un compartiment avec s3ls et affiche le nombre de fichiers et les tailles telles que

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

Script complet:

#!/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    

Il fait la taille du sous-répertoire, car Amazon renvoie le nom du répertoire et la taille de tout son contenu.

CloudWatch a maintenant un tableau de bord de service S3 par défaut qui le répertorie dans un graphique appelé "Bucket Size Bytes Average". Je pense que ce lien fonctionnera pour toute personne déjà connectée à AWS Console:

La méthode suivante utilise AWS PHP SDK pour obtenir la taille totale du compartiment.

// 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;

Cela fonctionne pour moi ..

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