# Storage Buckets

Storage Buckets adalah tipe repo di Hugging Face Hub yang menyediakan penyimpanan objek serupa S3, didukung oleh backend penyimpanan [Xet](./xet/index). Berbeda dengan [repository](./repositories) berbasis Git (model, dataset, Spaces), bucket bersifat **non-versioned** dan **mutable**, dirancang untuk kasus penggunaan di mana Anda membutuhkan penyimpanan yang sederhana dan cepat, seperti checkpoint pelatihan, log, artefak antara, atau kumpulan file besar lainnya yang tidak memerlukan kontrol versi.

Anda dapat berinteraksi dengan bucket menggunakan antarmuka web Hub, [CLI `hf`](https://huggingface.co/docs/huggingface_hub/guides/cli#hf-buckets), atau [API Python](https://huggingface.co/docs/huggingface_hub/guides/buckets).

> [!TIP]
> Buckets tersedia untuk semua pengguna dan organisasi. Lihat [hf.co/storage](https://huggingface.co/storage) untuk detail harga.

> [!TIP]
> Lihat [Panduan Migrasi](./storage-buckets-migration) untuk memindahkan data yang sudah ada ke bucket dari disk lokal, cloud lain, atau Hub, [Pola Akses](./storage-buckets-access) untuk cara mengakses data bucket dari alat Anda (mount sebagai filesystem, path `hf://`, volume mounts di Jobs/Spaces), [API Kompatibel S3](./storage-buckets-s3) untuk menggunakan tooling S3 yang sudah ada (AWS CLI, boto3, s5cmd), dan [Integrasi Bucket](./storage-buckets-integrations) untuk pustaka dengan dukungan bucket bawaan (seperti datatrove, LeRobot, dan Trackio) serta snippet untuk pustaka data seperti pandas, Dask, dan Spark.

## Buckets vs Repositori

Hub menawarkan dua jenis penyimpanan: **repository** berbasis Git untuk kerja kolaboratif yang terversi dan **bucket** untuk penyimpanan objek yang cepat dan dapat diubah.

| Fitur            | Repositori (berbasis Git)        | Storage Buckets                     |
| ------------------ | ------------------------------- | ----------------------------------- |
| Versi         | Riwayat Git lengkap                | None (mutable, overwrite-in-place)  |
| Tipe              | Model, Dataset, Spaces        | Bucket mandiri                   |
| Kasus penggunaan utama   | Menerbitkan artefak yang selesai   | Penyimpanan kerja / data antara |
| Operasi         | Hub API, Git push/pull          | S3-like `sync`, `cp`, `rm`          |
| Deduplikasi      | Xet level-chunk                 | Xet level-chunk                     |
| Pull Requests      | Ya                             | Tidak                                  |
| Kartu Model/Dataset| Ya                             | Tidak (tetapi README polos dirender)      |

Gunakan **repositories** ketika Anda membutuhkan riwayat versi, fitur kolaborasi (PR, diskusi), dan integrasi pustaka. Gunakan **buckets** ketika Anda memerlukan penyimpanan yang cepat dan dapat diubah untuk data yang sering berubah — file dapat ditimpa atau dihapus di tempatnya.

## Membuat Bucket

### Dari UI Hub

1. Buka [huggingface.co/new-bucket](https://huggingface.co/new-bucket):

2. Tentukan pemilik bucket: ini bisa menjadi Anda atau salah satu organisasi yang Anda ikuti.

3. Masukkan nama bucket.

4. Pilih apakah bucket harus bersifat publik atau privat.

5. Secara opsional, prapilih wilayah [CDN pre-warming](#pre-warming-and-cdn) untuk meng-cache data Anda lebih dekat ke komputasi Anda sejak awal.

Setelah membuat bucket, Anda seharusnya melihat halaman bucket:

### Dari CLI

```bash
# Create a bucket under your namespace
hf buckets create my-bucket

# Create a private bucket
hf buckets create my-bucket --private

# Create a bucket under an organization
hf buckets create my-org/shared-bucket
```

### Dari Python

```python
from huggingface_hub import create_bucket

# Create a bucket under your namespace
create_bucket("my-bucket")

# Create a private bucket
create_bucket("my-bucket", private=True)

# Create a bucket under an organization
create_bucket("my-org/shared-bucket")
```

### Mengubah visibilitas

Anda dapat mengubah visibilitas bucket setelah dibuat:

```bash
# Make a bucket private
hf buckets settings username/my-bucket --private

# Make it public again
hf buckets settings username/my-bucket --public
```

```python
from huggingface_hub import update_bucket_settings

update_bucket_settings("username/my-bucket", private=True)
update_bucket_settings("username/my-bucket", private=False)
```

Untuk referensi API Python lengkap termasuk menghapus, memindahkan, dan mendaftar bucket, lihat [panduan Buckets `huggingface_hub`](https://huggingface.co/docs/huggingface_hub/guides/buckets).

## Menjelajahi Bucket di Hub

Setiap bucket memiliki halaman di Hub tempat Anda dapat menelusuri isinya, menavigasi direktori, dan melihat detail file. Halaman bucket tersedia di `https://huggingface.co/buckets/<owner>/<bucket-name>`.

### Rendering README

Jika sebuah direktori di bucket Anda berisi file `README.md`, Hub akan merendernya di bawah daftar file pada halaman direktori tersebut. Hal ini berlaku baik di akar bucket maupun di dalam subdirektori mana pun — berguna untuk mendokumentasikan isi bucket, bagaimana data diorganisasikan, atau bagaimana alat hilir harus mengonsumsinya.

### Menampilkan dari CLI

Anda juga dapat menampilkan isi bucket dari CLI:

```bash
# List files in a bucket (with human-readable sizes)
hf buckets list julien-c/my-training-bucket -h
                     Feb 17 14:46  art/
                     Feb 17 14:58  arxivqa/
                     Feb 17 15:02  arxivqa2/
                     Feb 17 15:04  arxivqa3/
                     Feb 17 14:47  captcha/
                     Feb 17 14:53  captcha2/
                     Feb 24 17:22  julien/

# Recursive listing
hf buckets list julien-c/my-training-bucket/art -h -R
    423.6 MB         Feb 17 14:29  art/train-00000-of-00011.parquet
    441.0 MB         Feb 17 14:29  art/train-00001-of-00011.parquet
    521.7 MB         Feb 17 14:29  art/train-00002-of-00011.parquet
    481.4 MB         Feb 17 14:29  art/train-00003-of-00011.parquet
    444.6 MB         Feb 17 14:29  art/train-00004-of-00011.parquet
    461.6 MB         Feb 17 14:29  art/train-00005-of-00011.parquet
    466.4 MB         Feb 17 14:29  art/train-00006-of-00011.parquet
    486.3 MB         Feb 17 14:29  art/train-00007-of-00011.parquet
    477.0 MB         Feb 17 14:29  art/train-00008-of-00011.parquet
    454.0 MB         Feb 17 14:29  art/train-00009-of-00011.parquet
    483.1 MB         Feb 17 14:29  art/train-00010-of-00011.parquet

# Tree view
hf buckets list julien-c/my-training-bucket --tree -h -R
                        ├── art/
423.6 MB  Feb 17 14:29  │   ├── train-00000-of-00011.parquet
441.0 MB  Feb 17 14:29  │   ├── train-00001-of-00011.parquet
521.7 MB  Feb 17 14:29  │   ├── train-00002-of-00011.parquet
481.4 MB  Feb 17 14:29  │   ├── train-00003-of-00011.parquet
444.6 MB  Feb 17 14:29  │   ├── train-00004-of-00011.parquet
461.6 MB  Feb 17 14:29  │   ├── train-00005-of-00011.parquet
466.4 MB  Feb 17 14:29  │   ├── train-00006-of-00011.parquet
486.3 MB  Feb 17 14:29  │   ├── train-00007-of-00011.parquet
477.0 MB  Feb 17 14:29  │   ├── train-00008-of-00011.parquet
454.0 MB  Feb 17 14:29  │   ├── train-00009-of-00011.parquet
483.1 MB  Feb 17 14:29  │   └── train-00010-of-00011.parquet
                        ├── arxivqa/
495.9 MB  Feb 17 14:32  │   ├── train-00000-of-00164.parquet
518.3 MB  Feb 17 14:32  │   ├── train-00001-of-00164.parquet
495.5 MB  Feb 17 14:32  │   ├── train-00002-of-00164.parquet
486.6 MB  Feb 17 14:32  │   ├── train-00003-of-00164.parquet
490.4 MB  Feb 17 14:32  │   ├── train-00004-of-00164.parquet
...
```

## Mengelola File

Anda dapat mengunggah dan mengunduh file langsung dari halaman bucket di Hub, atau menggunakan CLI dan API Python untuk akses programatik. File bucket dirujuk menggunakan path `hf://buckets/` (misalnya, `hf://buckets/username/my-bucket/path/to/file`). Perintah `hf buckets cp` menangani transfer file individual, sedangkan `hf buckets sync` lebih cocok untuk direktori. Semua perintah berfungsi dalam kedua arah — dari lokal ke remote dan dari remote ke lokal.

Jika data Anda sudah berada di repositori model, dataset, atau Space (atau bucket lain), Anda dapat menyalinnya **di sisi server** dengan `hf buckets cp` — tanpa perlu mengunduh atau mengunggah ulang. Lihat [Menyalin file antar repositori dan bucket](#copying-files-between-repos-and-buckets).

### Mengunggah file

Untuk unggahan cepat, Anda dapat menyeret dan melepas file langsung ke halaman bucket di browser Anda. Untuk penggunaan programatik, `hf buckets cp` menyalin file individual ke dalam bucket. Sumbernya adalah path lokal dan tujuannya adalah path `hf://buckets/`. Anda juga dapat memip data dari stdin, yang berguna untuk konten yang dihasilkan secara programatik.

**CLI:**
```bash
# Upload a single file
hf buckets cp ./model.safetensors hf://buckets/username/my-bucket/models/model.safetensors

# Upload from stdin
cat config.json | hf buckets cp - hf://buckets/username/my-bucket/config.json
```

Di Python, gunakan `batch_bucket_files` untuk mengunggah satu atau lebih file dalam satu panggilan. Setiap entri adalah tuple `(local_path, remote_path)`.

**Python:**
```python
from huggingface_hub import batch_bucket_files

batch_bucket_files(
    "username/my-bucket",
    add=[
        ("./model.safetensors", "models/model.safetensors"),
        ("./config.json", "models/config.json"),
    ],
)
```

Untuk opsi unggah lainnya (byte mentah, unggah+hapus gabungan, dll.), lihat [panduan unggah `huggingface_hub`](https://huggingface.co/docs/huggingface_hub/guides/buckets#upload-files).

### Mengunduh file

Anda dapat mengunduh file individual langsung dari halaman bucket di Hub dengan mengklik file tersebut. Untuk akses programatik, sintaks pengunduhan mencerminkan sintaks pengunggahan — tukar sumber dan tujuan pada `hf buckets cp`. Anda juga dapat mengalirkan file ke stdout dengan menggunakan `-` sebagai tujuan, yang memungkinkan Anda memip konten bucket langsung ke alat lain.

**CLI:**
```bash
# Download a single file
hf buckets cp hf://buckets/username/my-bucket/models/model.safetensors ./model.safetensors

# Download to stdout and pipe
hf buckets cp hf://buckets/username/my-bucket/config.json - | jq .
```

Di Python, gunakan `download_bucket_files` dengan daftar tuple `(remote_path, local_path)`.

**Python:**
```python
from huggingface_hub import download_bucket_files

download_bucket_files(
    "username/my-bucket",
    files=[
        ("models/model.safetensors", "./local/model.safetensors"),
        ("config.json", "./local/config.json"),
    ],
)
```

Untuk unduhan yang lebih cepat menggunakan metadata yang telah diambil sebelumnya, lihat [panduan unduhan `huggingface_hub`](https://huggingface.co/docs/huggingface_hub/guides/buckets#download-files).

### Sinkronisasi direktori

Perintah `sync` bekerja seperti `rsync` atau `aws s3 sync` — membandingkan sumber dan tujuan, lalu hanya mentransfer file yang telah berubah. Ini adalah cara paling efisien untuk menjaga sinkronisasi antara direktori lokal dan bucket. Secara default, `sync` hanya menambahkan dan memperbarui file. Gunakan `--delete` untuk juga menghapus file di tujuan yang tidak lagi ada di sumber. Gunakan `--dry-run` untuk melihat pratinjau apa yang akan terjadi tanpa benar-benar mentransfer apa pun.

**CLI:**
```bash
# Upload a local directory to a bucket
hf buckets sync ./data hf://buckets/username/my-bucket/data

# Download from a bucket to a local directory
hf buckets sync hf://buckets/username/my-bucket/data ./data

# Sync with deletion of extraneous files
hf buckets sync ./data hf://buckets/username/my-bucket/data --delete

# Preview what would be synced without executing
hf buckets sync ./data hf://buckets/username/my-bucket/data --dry-run

# Plan and apply: review the sync plan before executing
hf buckets sync ./data hf://buckets/username/my-bucket/data --plan sync-plan.jsonl
# ... review the plan file, then apply it
hf buckets sync --apply sync-plan.jsonl
```

> [!TIP]
> `hf sync` adalah alias yang praktis untuk `hf buckets sync`.

**Python:**
```python
from huggingface_hub import sync_bucket

# Upload a local directory to a bucket
sync_bucket("./data", "hf://buckets/username/my-bucket/data")

# Download from a bucket to a local directory
sync_bucket("hf://buckets/username/my-bucket/data", "./data")
```

Perintah `sync` mendukung penyaringan (`--include`, `--exclude`), mode perbandingan (`--ignore-times`, `--existing`), dan alur kerja **plan-and-apply** untuk meninjau operasi sebelum dieksekusi. Untuk kumpulan opsi lengkap, lihat [panduan sinkronisasi `huggingface_hub`](https://huggingface.co/docs/huggingface_hub/guides/buckets#sync-directories).

### Menghapus file

Karena bucket bersifat non-versioned, penghapusan bersifat langsung dan permanen — tidak ada cara untuk memulihkan file yang dihapus. Gunakan `--dry-run` untuk memeriksa ulang sebelum menghapus file, terutama saat menggunakan `--recursive`.

**CLI:**
```bash
# Remove a single file
hf buckets rm username/my-bucket/old-model.bin

# Remove all files under a prefix
hf buckets rm username/my-bucket/logs/ --recursive

# Preview what would be deleted
hf buckets rm username/my-bucket/checkpoints/ --recursive --dry-run
```

**Python:**
```python
from huggingface_hub import batch_bucket_files

batch_bucket_files("username/my-bucket", delete=["old-model.bin", "logs/debug.log"])
```

Untuk opsi penghapusan lainnya (penyaringan berbasis pola, penghapusan rekursif, dll.), lihat [panduan penghapusan `huggingface_hub`](https://huggingface.co/docs/huggingface_hub/guides/buckets#delete-files).

### Menyalin file antar repositori dan bucket

Anda dapat menyalin file yang dilacak [Xet](./xet/index) dari repositori mana pun (model, dataset, Space) atau bucket ke bucket tujuan tanpa mengunggah ulang data. Penyalinan dilakukan di sisi server: hanya hash konten Xet yang dipindahkan, sehingga bahkan file yang sangat besar disalin secara instan berkat [deduplikasi tingkat chunk](./xet/deduplication).

> [!NOTE]
> Hanya file yang dilacak Xet yang disalin dari server ke server. File non-Xet berukuran kecil (misalnya, file konfigurasi dan README) diunduh dan diunggah ulang secara otomatis. Penyalinan sisi server juga mensyaratkan sumber dan tujuan berada di wilayah penyimpanan yang sama.

**CLI:**
```bash
hf buckets cp \
  hf://datasets/HuggingFaceFW/fineweb/data \
  hf://buckets/username/fineweb-data
```

**Python:**
```python
from huggingface_hub import HfApi

api = HfApi()

api.copy_files(
    "hf://datasets/HuggingFaceFW/fineweb/data",
    "hf://buckets/username/fineweb-data",
)
```

Anda memerlukan akses baca ke repositori atau bucket sumber dan akses tulis ke bucket tujuan.

Perhatikan bahwa mentransfer data ke arah sebaliknya, yaitu dari bucket ke repositori (model, dataset, Space) tanpa mengunggah ulang, belum tersedia, tetapi sudah ada dalam roadmap.

## Melacak Perubahan

Buckets bersifat mutable, sehingga alat yang mempertahankan view dari sebuah bucket — mounts, lapisan filesystem, daemon sinkronisasi, dashboard — perlu mengetahui kapan file berubah. Dua mekanisme yang tersedia:

- [Webhooks](./webhooks#buckets): callback HTTP ke server yang Anda kendalikan, atau [Job](./jobs) yang dimulai pada setiap perubahan — lihat [Memproses file baru di bucket dengan Jobs](./webhooks-guide-bucket-jobs).
- **Live follow**: aliran server-sent events yang disubskripsi oleh klien Anda.

### Ikuti secara langsung

`GET https://huggingface.co/api/buckets/<owner>/<bucket-name>/events` mengalirkan perubahan file bucket sebagai [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events). Permintaan harus membawa `Accept: text/event-stream` (jika tidak, akan mengembalikan `400`), dan membutuhkan akses baca yang sama dengan daftar bucket — token tidak diperlukan untuk bucket publik. Lihat [OpenAPI spec](https://huggingface.co/spaces/huggingface/openapi#tag/buckets/GET/api/buckets/{namespace}/{repo}/events) untuk skema parameter dan respons lengkap.

```bash
curl -N -H "Accept: text/event-stream" \
  -H "Authorization: Bearer $HF_TOKEN" \
  "https://huggingface.co/api/buckets/username/my-bucket/events"
```

> [!TIP]
> Di Python, Anda tidak perlu mengonsumsi stream secara manual. [`HfFileSystem`](/docs/huggingface_hub/guides/hf_file_system#keep-listings-fresh) akan mengikutinya untuk Anda dengan `live_follow=True`, sehingga daftar cache-nya tetap mutakhir ketika proses lain mengubah bucket:
>
> ```python
> from huggingface_hub import HfFileSystem
>
> hffs = HfFileSystem(live_follow=True)
> hffs.ls("buckets/username/my-bucket/data")  # starts following the bucket
> ```
>
> Perpustakaan yang menerima `storage_options` fsspec (pandas, PyArrow, ...) juga menerimanya.

Stream memancarkan empat jenis event:

| Peristiwa       | Data                                                  | Arti                                                                                       |
| ----------- | ----------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| `ready`     | `{"cursor": "..."}`                                   | Setiap replay yang diminta telah selesai dan perubahan langsung mengikuti.                                         |
| `changes`   | `{"cursor": "...", "changes": [...]}`                 | Seperangkat perubahan file, yang digabungkan dalam jendela waktu yang singkat.                                       |
| `reset`     | `{"reason": "cursor_too_old"}`                        | Titik resume tidak dapat diputar ulang; aliran berakhir dan Anda harus mendaftar ulang bucket.       |
| `reconnect` | `{"cursor": "..."}`                                   | Server sengaja menutup aliran; hubungkan kembali dengan kursor tersebut.                      |

Setiap entri dalam `changes` memiliki `path` dan `op` (`add`, `update`, atau `delete`). Sebuah `add` atau `update` juga membawa field yang berubah — `size`, `xetHash`, `uploadedAt`, `mtime`, `mtimeNanos` — sehingga sebuah `update` bisa sesedikit `uploadedAt` baru ketika file diunggah ulang secara identik. Field yang tidak berubah diabaikan; `mtime`/`mtimeNanos` juga bisa menjadi `null` jika unggahan menghapusnya, jadi perlakukan yang tidak ada dan `null` sama saja.

```
event: ready
data: {"cursor":"..."}

event: changes
data: {"cursor":"...","changes":[{"path":"data/train.txt","op":"add","size":20,"uploadedAt":"2026-09-16T09:21:45.000Z"},{"path":"data/old.txt","op":"delete"}]}
```

**Melanjutkan.** Aliran baru dimulai sejak Anda terhubung. Untuk juga mendapatkan perubahan yang terlewatkan, kirimkan `cursor` terakhir yang Anda terima (setiap event `ready` dan `changes` menyertakan satu) sebagai `?cursor=<cursor>`, atau timestamp sebagai `?since=<ISO timestamp>` (inklusif, misalnya `2026-09-16T09:21:45Z`).

Hanya **~15 menit terakhir** perubahan yang dapat diputar ulang. Jika `cursor` atau `since` Anda lebih lama dari itu, Anda akan menerima `reset` alih-alih pemutaran ulang: daftarkan bucket sekali untuk membangun ulang tampilan Anda, lalu ikuti lagi dari `cursor` pada event `ready` dari stream baru. Pemulihan (resuming) dimaksudkan untuk menjembatani jeda singkat seperti koneksi yang terputus atau restart; klien yang telah absen lebih lama harus mengharapkan untuk melakukan daftar ulang.

**Menghubungkan ulang.** Koneksi jangka panjang didaur ulang: sekitar setiap 20 menit (dan selama deployment), server mengirim `reconnect` lalu mengakhiri stream. Perlakukan *setiap* akhir stream dengan cara yang sama — hubungkan ulang dengan kursor terakhir yang Anda terima. Komentar `: ping` dikirim setiap 30 detik untuk menjaga koneksi tetap hidup, sehingga stream yang benar-benar hening dapat dianggap mati.

Respons `503` berarti live follow sementara tidak tersedia — coba lagi setelah jeda yang tercantum dalam header `Retry-After`.

## Pre-warming dan CDN

Buckets secara default berada di penyimpanan global Hub. Untuk beban kerja di mana lokasi penyimpanan secara langsung memengaruhi throughput, Anda dapat **menghangatkan sebelumnya** data bucket untuk membawanya lebih dekat ke komputasi Anda.

Pre-warming menyimpan file di lokasi edge yang dekat dengan penyedia cloud dan wilayah tertentu, sehingga pekerjaan Anda membaca data secara lokal alih-alih menariknya melintasi wilayah. Ini sangat berguna untuk:

- Klaster pelatihan yang membutuhkan akses cepat ke dataset atau checkpoint berukuran besar
- Konfigurasi multi-region di mana bagian-bagian berbeda dari pipeline berjalan di cloud yang berbeda
- Mendistribusikan artefak besar ke banyak konsumen di seluruh dunia

Lihat [hf.co/storage](https://huggingface.co/storage) untuk daftar wilayah yang tersedia dan detail tentang cara mengaktifkan pre-warming.

## Kasus Penggunaan

### Checkpoint pelatihan dan log

Saat menjalankan tugas pelatihan (misalnya, melalui [Jobs](./jobs)), simpan checkpoint dan log ke dalam bucket. Berbeda dengan repositori Git, Anda dapat menimpa checkpoint terbaru tanpa menumpuk riwayat versi, dan `sync` memastikan hanya data yang berubah yang ditransfer.

```bash
# After each evaluation step, sync checkpoints to a bucket
hf sync ./checkpoints hf://buckets/my-org/training-run-42/checkpoints
```

Karena bucket dibangun di atas [Xet](./xet/index), checkpoint berurutan di mana sebagian besar model dibekukan (frozen) mendapat manfaat dari deduplikasi tingkat chunk. Hanya chunk yang berubah yang diunggah.

Pada Jobs, Anda juga dapat mem-mount bucket dan menulis checkpoint langsung ke sana. Lihat [Melatih model di Jobs](./jobs-training#after-it-ends).

### Pipeline pemrosesan data

Buckets berfungsi sebagai area penampungan untuk alur kerja pemrosesan data. Proses data mentah, tulis output antara ke bucket, lalu promosikan artefak akhir ke repositori [Dataset](./datasets) yang ber-versi ketika pipeline selesai. Hal ini menjaga repositori ber-versi Anda tetap bersih sambil memberikan penyimpanan yang cepat dan dapat diubah untuk pipeline Anda. [datatrove](./storage-buckets-integrations#datatrove) mendukung pola ini secara langsung.

Perhatikan bahwa mentransfer data dari Bucket ke repositori tanpa mengunggah ulang belum tersedia, tetapi sudah ada dalam roadmap.

### Penyimpanan agen

AI agents membutuhkan penyimpanan sementara untuk hasil antara, keluaran alat, jejak, dan memori kerja. Bucket menyediakan tempat yang native di Hub untuk data ini: akses mutable yang cepat tanpa overhead Git, izin standar Hugging Face, dan dapat diidentifikasi melalui jalur `hf://buckets/` di seluruh ekosistem Hub.

### Cadangan bergulir

Buckets sangat cocok untuk memelihara cadangan berjalan (rolling backups). Dengan repositori [Dataset](./datasets) berbasis Git, penghapusan file yang sudah usang tidak membebaskan penyimpanan — riwayat Git menyimpan setiap versi masa lalu, sehingga Anda perlu memadatkan (squash) commit atau menulis ulang riwayat untuk benar-benar merebut kembali ruang. Dengan buckets, file lama benar-benar hilang setelah dihapus, dan Anda hanya membayar untuk apa yang saat ini disimpan.

```bash
# Sync today's backup, removing files that no longer exist locally
hf sync ./daily-backup hf://buckets/my-user/backups/latest --delete
```

### Menghubungkan model ke bucket

Anda dapat membuat tautan dua arah antara model dan bucket dengan menambahkan field `buckets` ke metadata kartu model. Model yang ditautkan kemudian akan muncul di halaman bucket, dan bucket akan muncul sebagai tag di halaman model.

```yaml
# In the model card YAML frontmatter
buckets:
- my-org/my-bucket
```

Lihat [Menentukan bucket](./model-cards#specifying-a-bucket) dalam dokumentasi kartu model untuk detail lebih lanjut.

## Harga

Storage Buckets ditagih berdasarkan jumlah data yang disimpan, dengan harga sederhana per TB. Paket Enterprise mendapat manfaat dari penagihan berbasis dedup, di mana chunk yang dibagikan antar file secara langsung mengurangi jejak yang ditagih.

Untuk repositori lainnya, bucket dapat dibuat secara gratis dan memiliki kuota penyimpanan gratis. Untuk penggunaan di atas [tier gratis](https://huggingface.co/docs/hub/storage-limits), lihat [hf.co/storage](https://huggingface.co/storage). Untuk informasi penagihan secara umum, lihat dokumentasi [Billing](./billing).