getsentry/objectstore

Letzte erfasste Quellaktivität: 3. August 2026 um 11:09

SkillsMP-Katalog aktualisiert: 2. November 2026 um 18:02

gesammelte Skills: 1

GitHub-Stars: 15
GitHub-Forks: 5

Mit einem KI-Assistenten installieren

Diesen Prompt kopieren und in den verwendeten KI-Assistenten einfügen.

Follow https://skillsmp.com/skill-install/prompt.md to install Agent Skills from https://github.com/getsentry/objectstore.

README des Repositorys

README-Quelldatei: README.md

README-Quelldatei lesen

Vollständige README anzeigen

# Objectstore Objectstore is a data storage platform for blobs, files, and other unstructured data at Sentry. It comprises a service with an RPC interface that internally manages multiple backends, client libraries for easy integration, and a set of utilities to manage stored data. <img width="531" height="716" alt="overview" src="https://github.com/user-attachments/assets/e9a4df55-591c-495f-b2a6-60d76d49958e" /> ## Internals The platform is split into the following core components: - `objectstore-server`: An `HTTP` server that exposes blob storage and calls functionality from the internal services. This crate creates the `objectstore` binary. See the [server architecture docs] for more information. - `objectstore-service`: The core object storage logic, including backend implementations and storage policies. See the [service architecture docs] for more information. - `objectstore-types`: Shared type definitions for the client and server, including metadata, scopes, expiration, and permissions. - `objectstore-log`: Logging macros and subscriber initialization shared across service components. - `objectstore-metrics`: Metrics macros and DogStatsD initialization shared across service components. - `objectstore-options`: Runtime options backed by [`sentry-options`](https://crates.io/crates/sentry-options), providing dynamic configuration to service components. - `objectstore-test`: Test utilities shared across the workspace. - `clients`: The Rust and Python client library SDKs, which expose high-performance blob storage access. [server architecture docs]: https://getsentry.github.io/objectstore/rust/objectstore_server/index.html [service architecture docs]: https://getsentry.github.io/objectstore/rust/objectstore_service/index.html Additionally, it contains a number of utilities: - `stresstest`: A stresstest binary that can run various workloads against storage backends. ## Usage Objectstore consists of a stateless service that connects to one or more storage backends, and client libraries for Python and Rust. To use objectstore, configure the desired backends, run the service, and connect to it using one of the provided clients. ### Configuration The objectstore service is configured through a configuration file and environment variables. If both are provided, environment variables take precedence and override the configuration file settings. See the [config docs] for a complete list of available backends and options. An example configuration file that uses the local file system for storage can be found in this [example file]. [config docs]: https://getsentry.github.io/objectstore/rust/objectstore_server/config/ [example file]: objectstore-server/config/local.example.yaml ### Docker A pre-built Docker container is published at `ghcr.io/getsentry/objectstore`, supporting both `amd64` and `arm64` architectures. To run the container, mount your configuration file and data volume: ```sh docker run -d \ --name objectstore \ --volume ./config.yaml:/etc/objectstore/config.yaml \ --volume data-volume:/data \ --publish 127.0.0.1:8888:8888 \ ghcr.io/getsentry/objectstore:latest \ --config /etc/objectstore/config.yaml run ``` The command above assumes a configuration file named `config.yaml` in the current directory and publishes the service on port `8888`. Adjust the volume mount path and port mapping as needed for your setup. ### Devservices For Sentry development environments, we provide a [devservice] that can be referenced from any project that needs to run objectstore. To use it, add the following to the `dependencies` section in your `devservices/config.yml`: ```yaml objectstore: description: Storage for files and blobs remote: repo_name: objectstore branch: main repo_link: https://github.com/getsentry/objectstore.git mode: containerized ``` In the Sentry backend, objectstore is integrated and can be started using `devservices up --mode=objectstore`. No additional configuration is necessary, simply import a client from `sentry.objectstore`. [devservice]: https://develop.sentry.dev/development-infrastructure/devservices/ ### Clients To integrate objectstore into your application, you can either use the HTTP API directly or leverage one of the higher-level client SDKs. We provide official client libraries for both [Python] and [Rust], which handle connection management, retries, and compression for you. Refer to the SDK documentation for detailed setup and usage instructions. [Python]: https://getsentry.github.io/objectstore/python/ [Rust]: https://getsentry.github.io/objectstore/rust/objectstore_client/ ## Building Ensure the latest stable Rust toolchain is installed on your machine. A release build can be created with: ```sh cargo build --release --locked ``` The server binary will be located at `target/release/objectstore`. ### Docker Container To build the Docker container, first build the release binary, then build the container: ```sh docker build -f Dockerfile target/release/ ``` The last argument must be the path to the directory that contains the `objectstore` binary. ### Cross-building for AMD64 from ARM64 We have utilities to cross-build an AMD64 container from an ARM64 host, such as a macOS machine running on Apple Silicon. To do this, run: ```sh scripts/build-cross.sh ``` This script will take care of the entire cross-compilation build process inside an ARM-based Docker container and use the project's `target/` directory for caching and build output. The build results in two artifacts: - The binary at `target/x86_64-unknown-linux-gnu/release/objectstore` - The docker container, tagged with `objectstore:latest` Debug info is stripped by default to reduce binary size. To include debug symbols, set `CARGO_PROFILE_RELEASE_DEBUG=true` before running the script. ## Development ### Environment Setup Before starting development, ensure you have development tools and environment configured: ```bash # Option 1: Use direnv (recommended) direnv allow # Option 2: Manually source the environment source .envrc ``` This will create and activate the `.venv` virtual environment with the correct Python version, install development tools, and export environment variables for development. ### Devservices Our test suite also tests backends that require development services to connect to. We recommend to use [`devservices`] and start objectstore in "full" mode. Note that this does not start objectstore itself, but only its dependencies: [`devservices`]: https://github.com/getsentry/devservices ```sh devservices up objectstore --mode=full ``` Devservices continue to run in the background until explicitly stopped. If you prefer to start containers manually, please check `devservices/config.yml` for the required images and configuration, such as port mapping. - For **Google BigTable**, we automatically create a table with the required column families. - For **Google Cloud Storage** (GCS), a test bucket is already configured in the dev container. - For **SeaweedFS** (S3-compatible), a public test bucket is created on startup. The emulators example config is pre-configured with a tiered configuration using both backends. To use it: ```sh cargo run -- -c objectstore-server/config/emulators.example.yaml run ``` ### Editor Setup We recommend using **Visual Studio Code** with the recommended extensions. The project includes VSCode configuration that will: - Automatically format code on save - Automatically organize imports on save - Show linting errors inline When you open this project in VSCode, it will prompt you to install the recommended extensions if they're not already installed. ### Code Quality We recommend using Rust Analyzer and clippy, which will apply formatting and warn about lints during development. If you use the recommended VSCode setup, this is done automatically for you. To run linters manually, use: ```sh # Check and fix formatting cargo fmt --all # Lint all features cargo clippy --workspace --all-targets --all-features ``` ### Development Server You can run a development build of the server with `cargo run`. Objectstore can be configured through a configuration file or environment variables. Note that if both are given, environment variables override the config file. For this reason, we do **not** provide default configuration variables in `.envrc`. ```sh # Option 1: Configuration file cargo run -- -c objectstore-server/config/local.example.yaml run # Option 2: Environment variables export OS__STORAGE__TYPE=filesystem export OS__STORAGE__PATH=data cargo run -- run ``` You can copy and save additional config files next to the examples in `objectstore-server/config`. All other files are ignored by git. ### Heap Profiling Production release builds include on-demand heap profiling via jemalloc. It can be enabled and disabled through HTTP endpoints that are only reachable from loopback. To capture a heap profile from a running server, for example on localhost with default port: ```sh # Enable sampling, let the workload run, then dump a profile curl -X POST http://localhost:8888/debug/pprof/enable curl http://localhost:8888/debug/pprof/heap > heap.pb.gz # Disable sampling when done curl -X POST http://localhost:8888/debug/pprof/disable ``` Profiles are unsymbolicated — you need the server binary to resolve stack frames. Copy it from the Docker image with: ```sh docker create --name tmp <image> docker cp tmp:/bin/entrypoint ./objectstore docker rm tmp ``` To analyze profile dumps, use the standalone `pprof` tool. The go builtin tool does not support symbolizing ELF files on macOS hosts: ```sh go install github.com/google/pprof@latest ``` Then point pprof at the binary and the heap dump(s) you want to analyze: ```sh $(go env GOPATH)/bin/pprof -top objectstore heap.pb.gz # To isolate growth between two snapshots, use the -diff_base flag: $(go env GOPATH)/bin/pprof -top -diff_base before.pb.gz objectstore after.pb.gz # Interactive browser UI with flamegraph: $(go env GOPATH)/bin/pprof -http=:8080 objectstore heap.pb.gz ``` The sampling overhead is around 5%, so profiling can be left enabled for an extended capture window safely. ### Tests To run tests: ```sh cargo test --workspace --all-features ``` ## Utilities Run the stresstest binary against the running server with: ```sh cargo run --release -p stresstest -- -c stresstest/config/example.yaml ``` Similar to the objectstore server, you can find example configuration files in the `config` subfolder. Copy and save your own files there, as they will not be tracked by git. To load test the Bigtable backend directly (bypassing the HTTP layer), use the `bigtable-bench` tool. See [`bigtable-bench/README.md`](bigtable-bench/README.md) for usage and examples. ## License Like Sentry, Objectstore is licensed under the FSL. See the `LICENSE.md` file and [this blog post](https://blog.sentry.io/introducing-the-functional-source-license-freedom-without-free-riding/) for more information.

README des Repositorys wird geladen…

Skills in diesem Repository

Netzwerk- und Computersystemadministratoren

1 Berufskategorien · 100% klassifiziert

Skill

Beruf

Beschreibung

Aktualisiert

devservices-troubleshooting

Netzwerk- und Computersystemadministratoren

Fix connection-refused/RPC Unavailable errors in objectstore-service tests by starting devservices (GCS/Bigtable emulators)

Quellsprache: Englisch

2026-08-03

Es werden 1 von 1 gesammelten Skills angezeigt.