Name: 对象存储库
Author: jeremyhahn

使用说明

去-objstore

Go的统一对象存储和文件系统抽象库。

特性

跨所有存储后端的统一API
立面模式，所有存储操作都有一个经过验证的入口点
同时使用多个存储后端
针对路径遍历和注入的输入验证
后端之间的复制和同步，可选加密
用于日志记录和身份验证的可插拔适配器
具有目录操作的文件系统接口
自动删除和存档的生命周期策略
使用可插拔加密器进行静态加密
服务器协议：gRPC、REST、QUIC/HTTP3、Unix套接字和MCP
CLI工具可通过文件、环境或标志进行配置
用于嵌入C/C++应用程序的C API
TLS/mTLS支持

快速开始

安装

go get github.com/jeremyhahn/go-objstore

基本用途（立面图案-推荐）

package main

import (
    "bytes"
    "context"
    "fmt"
    "io"

    "github.com/jeremyhahn/go-objstore/pkg/common"
    "github.com/jeremyhahn/go-objstore/pkg/factory"
    "github.com/jeremyhahn/go-objstore/pkg/objstore"
)

func main() {
    // Create storage backends
    local, _ := factory.NewStorage("local", map[string]string{
        "path": "/tmp/my-storage",
    })

    // Initialize facade (do this once at app startup)
    objstore.Initialize(&objstore.FacadeConfig{
        Backends: map[string]common.Storage{
            "local": local,
        },
        DefaultBackend: "local",
    })
    defer objstore.Reset()

    // Store data
    data := []byte("Hello, World!")
    objstore.Put("greeting.txt", bytes.NewReader(data))

    // Retrieve data
    reader, _ := objstore.Get("greeting.txt")
    defer reader.Close()

    content, _ := io.ReadAll(reader)
    fmt.Println(string(content))  // Output: Hello, World!

    // Delete data
    objstore.Delete("greeting.txt")
}

直接存储访问（传统）

为了向后兼容，您仍然可以使用直接存储访问：

// Create a storage backend
storage, err := factory.NewStorage("local", map[string]string{
    "path": "/tmp/my-storage",
})
if err != nil {
    panic(err)
}

// Use storage directly
storage.Put("greeting.txt", bytes.NewReader(data))

注：将facade模式用于新代码。它添加了输入验证、多后端支持和经过净化的错误消息。

支持的后端

后端	类型	用例
本地	存储	开发、测试、本地存档
S3	存储	AWS对象存储，高可用性
MinIO	存储	自托管S3兼容对象存储
GCS	存储	谷歌云对象存储
Azure Blob	存储	Microsoft Azure对象存储
内存	存储	单元测试，临时/内存中
Glacier	仅存档	AWS长期冷存储
Azure存档	仅存档	Azure长期冷存储

后端配置

本地存储

storage, _ := factory.NewStorage("local", map[string]string{
    "path": "/var/data/storage",
})

记忆存储

storage, _ := factory.NewStorage("memory", map[string]string{})

亚马逊S3

storage, _ := factory.NewStorage("s3", map[string]string{
    "region": "us-east-1",
    "bucket": "my-bucket",
    // Optional: for custom endpoints (MinIO, LocalStack)
    "endpoint":       "http://localhost:9000",
    "forcePathStyle": "true",
    "accessKey":      "minioadmin",
    "secretKey":      "minioadmin",
})

MinIO

storage, _ := factory.NewStorage("minio", map[string]string{
    "bucket":    "my-bucket",
    "endpoint":  "http://localhost:9000",
    "accessKey": "minioadmin",
    "secretKey": "minioadmin",
    // Optional: defaults to "us-east-1"
    "region":    "us-east-1",
})

谷歌云存储

storage, _ := factory.NewStorage("gcs", map[string]string{
    "bucket": "my-gcs-bucket",
})

Azure Blob存储

storage, _ := factory.NewStorage("azure", map[string]string{
    "accountName":   "myaccount",
    "accountKey":    "base64key==",
    "containerName": "mycontainer",
})

高级功能

立面图案（推荐）

facade是一个单独的API，用于处理多个存储后端。它在每个入口点都一致地验证输入。

好处

同时使用多个存储后端
使用目标定位特定后端 backend:key 语法
根据路径遍历、注入和格式错误的键验证输入
所有存储操作的单一入口点
未披露内部细节的山宁泰错误消息

多后端示例

import (
    "github.com/jeremyhahn/go-objstore/pkg/common"
    "github.com/jeremyhahn/go-objstore/pkg/factory"
    "github.com/jeremyhahn/go-objstore/pkg/objstore"
)

// Create multiple storage backends
local, _ := factory.NewStorage("local", map[string]string{
    "path": "/tmp/local-storage",
})

s3, _ := factory.NewStorage("s3", map[string]string{
    "bucket": "my-bucket",
    "region": "us-east-1",
})

// Initialize facade once at application startup
objstore.Initialize(&objstore.FacadeConfig{
    Backends: map[string]common.Storage{
        "local": local,
        "s3":    s3,
    },
    DefaultBackend: "local",
})
defer objstore.Reset()

// Use default backend
objstore.Put("file.txt", data)

// Target specific backend
objstore.PutWithContext(ctx, "s3:backups/file.txt", data)
objstore.PutWithContext(ctx, "local:cache/temp.dat", data)

// Get from specific backend
reader, _ := objstore.GetWithContext(ctx, "s3:backups/file.txt")

// List all available backends
backends := objstore.Backends()  // ["local", "s3"]

安全特性

facade会自动验证所有输入以防止攻击：

// These all fail with validation errors
objstore.Put("../../../etc/passwd", data)        // Path traversal blocked
objstore.Put("/etc/passwd", data)                // Absolute path blocked
objstore.Put("file\x00.txt", data)              // Null byte blocked
objstore.Put("file\n.txt", data)                // Control character blocked
objstore.PutWithContext(ctx, "INVALID:key", data) // Invalid backend name blocked

有关详细的迁移指南和示例，请参阅 docs/facade-migration.md.

文件系统接口

将对象存储与熟悉的文件系统操作一起使用：

import "github.com/jeremyhahn/go-objstore/pkg/storagefs"

fs := storagefs.New(storage)

// Create directories
fs.MkdirAll("docs/2024", 0755)

// Create and write to a file
file, _ := fs.Create("docs/readme.txt")
file.WriteString("Hello from StorageFS!")
file.Close()

// List directory contents
dir, _ := fs.Open("docs")
defer dir.Close()

entries, _ := dir.Readdir(-1)
for _, entry := range entries {
    fmt.Printf("%s (dir: %v, size: %d bytes)\n",
        entry.Name(), entry.IsDir(), entry.Size())
}

// Read directory names only
dir2, _ := fs.Open("docs")
names, _ := dir2.Readdirnames(-1)
for _, name := range names {
    fmt.Println(name)
}

生命周期策略

自动化数据保留和归档：

import (
    "time"
    "github.com/jeremyhahn/go-objstore/pkg/common"
)

// Delete old logs after 30 days
deletePolicy := common.LifecyclePolicy{
    ID:        "cleanup-old-logs",
    Prefix:    "logs/",
    Action:    "delete",
    Retention: 30 * 24 * time.Hour,
}
storage.AddPolicy(deletePolicy)

// Archive data to Glacier after 90 days
glacier, _ := factory.NewArchiver("glacier", map[string]string{
    "vaultName": "long-term-archive",
    "region":    "us-east-1",
})

archivePolicy := common.LifecyclePolicy{
    ID:          "archive-old-data",
    Prefix:      "data/",
    Action:      "archive",
    Destination: glacier,
    Retention:   90 * 24 * time.Hour,
}
storage.AddPolicy(archivePolicy)

复制

使用可选加密在存储后端之间复制和同步数据：

import (
    "context"
    "time"
    "github.com/jeremyhahn/go-objstore/pkg/objstore"
)

// Enable replication on the default backend
objstore.EnableReplication("", &objstore.ReplicationConfig{
    PolicyFilePath:  "/data/replication-policies.json",
    Interval:        10 * time.Minute,
    RunInBackground: true,
})

// Get the replication manager
mgr, _ := objstore.GetReplicationManager("")

// Create a local-to-local replication policy
policy := common.ReplicationPolicy{
    ID:                  "backup-daily",
    SourceBackend:       "local",
    SourceSettings:      map[string]string{"path": "/data/source"},
    SourcePrefix:        "documents/",
    DestinationBackend:  "local",
    DestinationSettings: map[string]string{"path": "/data/backup"},
    CheckInterval:       1 * time.Hour,
    Enabled:             true,
    ReplicationMode:     common.ReplicationModeTransparent,
}

// Add the policy
mgr.AddPolicy(policy)

// Trigger sync for a specific policy
result, _ := mgr.SyncPolicy(context.Background(), "backup-daily")
fmt.Printf("Synced %d objects, %d bytes\n", result.Synced, result.BytesTotal)

// Or sync all policies in parallel
result, _ := mgr.SyncAllParallel(context.Background(), 4)

复制模式：

transparent：在源处解密并在目标处重新加密（当源和目标具有不同的DEK时使用）
opaque：按原样复制加密的blob，无需DEK操作（用于备份场景或性能）

三层加密：

后端静态加密（EncryptionPolicy.Backend）
源DEK层（EncryptionPolicy.Source）
目标DEK层（EncryptionPolicy.Termination）

静态加密

为任何存储后端添加透明加密：

import (
    "github.com/jeremyhahn/go-objstore/pkg/common"
)

// Create an encrypter factory (example: using a KMS adapter)
factory := yourKMSAdapter.GetEncrypterFactory()

// Wrap the storage with encryption
encrypted := common.NewEncryptedStorage(storage, factory)

// Now all Put/Get operations are encrypted/decrypted transparently
encrypted.Put("sensitive-data.txt", reader)
encrypted.Get("sensitive-data.txt")

请参阅加密示例使用KMS适配器实现完整的AES-256-GCM。

身份验证和授权

身份验证和授权是可插拔的：

import (
    "github.com/jeremyhahn/go-objstore/pkg/adapters"
)

// Default: allow-all (library-first, no auth required)
auth := adapters.NewNoOpAuthenticator()
authz := adapters.NewNoOpAuthorizer()

// Bearer token authentication
auth := adapters.NewBearerTokenAuthenticator(
    func(ctx context.Context, token string) (*adapters.Principal, error) {
        // Validate token and return principal
        return &adapters.Principal{
            ID:    "user-123",
            Name:  "Alice",
            Type:  "user",
            Roles: []string{"reader"},
        }, nil
    },
)

// Role-based authorization
authz := adapters.NewRBACAuthorizer(map[string][]string{
    "reader":  {adapters.ActionRead, adapters.ActionList},
    "editor":  {adapters.ActionRead, adapters.ActionWrite, adapters.ActionList},
    "admin":   {"*"}, // Wildcard grants all actions
})

// Composite authenticator (try multiple methods)
auth := adapters.NewCompositeAuthenticator(
    adapters.NewBearerTokenAuthenticator(validateJWT),
    adapters.NewMTLSAuthenticator(extractFromCert, caRoots),
)

动作词汇： read, write, delete, list, admin

资源类别： object, policy, replication

Unix套接字身份验证（Linux）： Unix套接字服务器通过SO_PEERCRED从进程凭据（UID/GID）中导出主体；套接字文件权限是主要的访问门。

审计日志

将存储操作记录到审核日志中：

import (
    "github.com/jeremyhahn/go-objstore/pkg/audit"
)

// Create an audit logger
auditLog := audit.NewDefaultAuditLogger()

// Log authentication events
auditLog.LogAuthFailure(ctx, "user-123", "alice", "192.168.1.1", "req-456", "invalid credentials")
auditLog.LogAuthSuccess(ctx, "user-123", "alice", "192.168.1.1", "req-456")

// Log object operations
auditLog.LogObjectMutation(
    ctx,
    audit.EventObjectCreated,
    "user-123", "alice", "bucket", "file.txt",
    "192.168.1.1", "req-456",
    1024, // bytes transferred
    audit.ResultSuccess,
    nil,  // error
)

// Log access
auditLog.LogObjectAccess(ctx, "user-123", "alice", "bucket", "file.txt",
    "192.168.1.1", "req-456", audit.ResultSuccess, nil)

// Log policy changes
auditLog.LogPolicyChange(ctx, "user-123", "alice", "bucket", "policy-1",
    "192.168.1.1", "req-456", audit.ResultSuccess, nil)

事件类型： AUTH_FAILURE、AUTH_SUCCESS、OBJECT_CREATED、OBJECT_DELETED、OBJECT_ACCESSED、OBJECT_METADATA_UPDATED、OBJECT_ARCHIVED、POLICY_CHANGED、LIST_OBJECTS

上下文支持

所有操作都支持取消和超时上下文：

import "context"

ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

// Context-aware operations
err := storage.PutWithContext(ctx, "key", data)
reader, err := storage.GetWithContext(ctx, "key")
err = storage.DeleteWithContext(ctx, "key")

元数据支持

存储和检索自定义元数据：

metadata := &common.Metadata{
    ContentType:     "application/json",
    ContentEncoding: "utf-8",
    Custom: map[string]string{
        "author":  "john-doe",
        "version": "1.0",
    },
}

// Put with metadata
storage.PutWithMetadata(ctx, "data.json", reader, metadata)

// Get metadata
meta, _ := storage.GetMetadata(ctx, "data.json")
fmt.Println(meta.Custom["author"])  // Output: john-doe

// Update metadata
meta.Custom["version"] = "2.0"
storage.UpdateMetadata(ctx, "data.json", meta)

带分页的列表

高效地列出大型目录：

opts := &common.ListOptions{
    Prefix:     "logs/2024/",
    MaxResults: 100,
    Delimiter:  "/",
}

result, _ := storage.ListWithOptions(ctx, opts)
for _, obj := range result.Objects {
    fmt.Printf("%s (%d bytes)\n", obj.Key, obj.Metadata.Size)
}

// Get next page
if result.Truncated {
    opts.ContinueFrom = result.NextToken
    nextPage, _ := storage.ListWithOptions(ctx, opts)
}

客户端SDK

官方客户端SDK支持六种语言。每个都实现了相同的19个规范操作，并自动选择可用协议（REST、gRPC或QUIC）。

语言	包	操作	协议
python `pip install go-objstore`	19	REST、gRPC、QUIC
红宝石	`gem install go-objstore`	19	REST、gRPC、QUIC
去吧	`go get github.com/jeremyhahn/go-objstore/api/sdks/go`	19	REST、gRPC、QUIC
生锈	`cargo add go-objstore`	19	REST、gRPC、QUIC
Types/JavaScript	`npm install @go-objstore/client`	19	REST、gRPC、QUIC
C `dotnet add go-objstore`	19	REST、gRPC、QUIC

规范操作（19）：

对象：放置、获取、删除、列出、存在
元数据：获取元数据、更新元数据
服务：健康
存档：存档
生命周期：添加策略、删除策略、获取策略、应用策略
复制：添加复制策略、删除复制策略、GetReplicationPolicy、GetReplicationPolicy、触发器复制、GetReplicationStatus

有关每种语言的安装和使用，请参阅 api/sdks/README.md.

C API

在C/C++应用程序中嵌入go-objstore：

#include "libobjstore.h"

int main(void) {
    // Create storage
    char *keys[] = {"path"};
    char *values[] = {"/tmp/storage"};
    int handle = ObjstoreNewStorage("local", keys, values, 1);

    // Store data
    char *data = "Hello from C!";
    ObjstorePut(handle, "test.txt", data, strlen(data));

    // Retrieve data
    char buffer[256];
    int len = ObjstoreGet(handle, "test.txt", buffer, 256);
    buffer[len] = '\0';
    printf("%s\n", buffer);

    // Cleanup
    ObjstoreDelete(handle, "test.txt");
    ObjstoreClose(handle);
    return 0;
}

构建说明：

# Build the shared library
make lib

# Compile your C program
gcc -o myapp myapp.c -L./bin -lobjstore -lpthread -ldl

# Run with library path
LD_LIBRARY_PATH=./bin ./myapp

文档

文件在 docs/ 目录。

建筑

配置

配置指南
存储后端
服务器（gRPC、REST、QUIC、Unix套接字、MCP）
加密
生命周期策略
CLI工具

用法

其他资源

例子

示例代码可在示例/ 目录：

基本用法 -简单的存储操作
C客户端 -使用C应用程序
加密 -使用KMS适配器进行透明加密
立面使用 -多后端立面图案
gRPC客户端 -gRPC客户端使用情况
生命周期策略 -自动保留和归档
StorageFS -文件系统接口示例

项目结构

go-objstore/
├── pkg/                        # Core packages
│   ├── factory/               # Backend factory
│   ├── common/                # Shared interfaces and types
│   ├── local/                 # Local filesystem backend
│   ├── memory/                # In-memory storage backend
│   ├── s3/                    # Amazon S3 backend
│   ├── gcs/                   # Google Cloud Storage backend
│   ├── azure/                 # Azure Blob Storage backend
│   ├── minio/                 # MinIO S3-compatible backend
│   ├── glacier/               # AWS Glacier archiver
│   ├── azurearchive/          # Azure Archive archiver
│   ├── storagefs/             # Filesystem abstraction
│   ├── replication/           # Replication engine
│   ├── audit/                 # Audit logging
│   ├── adapters/              # Custom logging and TLS adapters
│   ├── pool/                  # Volume pool (backend placement)
│   ├── cli/                   # CLI commands and config
│   ├── version/               # Version information
│   ├── objstore/              # Facade pattern implementation
│   └── server/                # Server implementations
│       ├── grpc/              # gRPC server
│       ├── rest/              # REST API server
│       ├── quic/              # QUIC/HTTP3 server
│       ├── unix/              # Unix socket server
│       ├── mcp/               # MCP server
│       └── middleware/        # Rate limiting and security middleware
├── cmd/
│   ├── objstore/              # CLI binary
│   ├── objstore-server/       # All-in-one multi-protocol server
│   ├── objstore-grpc-server/  # Individual gRPC server
│   ├── objstore-rest-server/  # Individual REST server
│   ├── objstore-quic-server/  # Individual QUIC/HTTP3 server
│   ├── objstore-mcp-server/   # Individual MCP server
│   └── objstorelib/           # C API shared library
├── api/                       # API definitions
│   ├── proto/                 # Protocol buffers for gRPC
│   ├── openapi/               # OpenAPI specs for REST
│   ├── mcp/                   # MCP server configuration
│   └── sdks/                  # Official client SDKs (Python, Ruby, Go, Rust, TypeScript, C#)
├── examples/                  # Usage examples
├── test/integration/          # Integration tests
└── docs/                      # Documentation

发展

先决条件

达到1.26.4或更高
Docker（用于集成测试）
制造

建筑

# Install dependencies
make deps

# Build the library
make build

# Build CLI tool
make build-cli

# Build server
make build-server

# Build C shared library
make lib

测试

# Run unit tests (fast, in-memory)
make test

# Run all integration tests (backends + CLI)
make integration-test

# Run ALL integration tests including servers
make integration-test-all

# Run specific backend tests
make integration-test-local
make integration-test-s3
make integration-test-azure
make integration-test-gcs
make integration-test-minio
make integration-test-factory

# Run CLI integration tests
make integration-test-cli

# Run server integration tests (gRPC, REST, QUIC, Unix socket, MCP)
make test-servers

# Generate coverage report
make coverage-report

# Check per-package coverage (highlights packages under 90%)
make coverage-check

测试覆盖率

单元测试在没有外部依赖的情况下运行。集成测试对服务器和后端使用基于Docker的模拟器。CLI集成测试会生成CLI二进制文件（如果不存在）。安全扫描使用gosec和govulncheck。有关覆盖率统计信息，请参阅上面的徽章或运行 make coverage-report.

建筑

存储接口

所有后端都实现了一个通用的存储接口：

type Storage interface {
    LifecycleManager  // Embedded: AddPolicy, RemovePolicy, GetPolicies

    // Configuration
    Configure(settings map[string]string) error

    // Basic operations
    Put(key string, data io.Reader) error
    Get(key string) (io.ReadCloser, error)
    Delete(key string) error
    List(prefix string) ([]string, error)

    // Context-aware operations
    PutWithContext(ctx context.Context, key string, data io.Reader) error
    GetWithContext(ctx context.Context, key string) (io.ReadCloser, error)
    DeleteWithContext(ctx context.Context, key string) error
    ListWithContext(ctx context.Context, prefix string) ([]string, error)

    // Metadata operations
    PutWithMetadata(ctx context.Context, key string, data io.Reader, metadata *Metadata) error
    GetMetadata(ctx context.Context, key string) (*Metadata, error)
    UpdateMetadata(ctx context.Context, key string, metadata *Metadata) error

    // Advanced operations
    Exists(ctx context.Context, key string) (bool, error)
    ListWithOptions(ctx context.Context, opts *ListOptions) (*ListResult, error)
    Archive(key string, destination Archiver) error
}

工厂模式

工厂通过一个功能创建后端：

storage, err := factory.NewStorage(backendType, config)
archiver, err := factory.NewArchiver(archiverType, config)

它将后端特定的初始化隐藏在一个接口后面。

演出

所有后端都支持并发读写。缓冲I/O有助于提高吞吐量。本地后端速度最快；云后端增加了网络开销。看 docs/testing.md 基准测试。

最佳实践

始终关闭Get（）返回的读取器，以防止资源泄漏
处理所有存储操作中的错误
使用上下文取消和超时长时间操作
启用生命周期策略以进行自动清理
根据成本、性能和耐用性需求明智地选择后端
当您需要标准文件系统操作时，请使用StorageFS
在部署到云端之前，使用模拟器进行测试

服务器接口

运行服务器有两种方法：一种是多协议二进制文件，另一种是每种协议的单个二进制文件。

CLI工具

# Run the CLI
./bin/objstore --help

# Store an object from file
./bin/objstore put myfile.txt mykey

# Store from stdin
echo "Hello World" | ./bin/objstore put - mykey
cat data.txt | ./bin/objstore put - mykey

# Retrieve an object to file
./bin/objstore get mykey output.txt

# Retrieve to stdout
./bin/objstore get mykey
./bin/objstore get mykey -

# Pipe between backends (copy/migrate data)
./bin/objstore get mykey --backend local | \
  ./bin/objstore put - mykey --backend s3

# List objects
./bin/objstore list

# Check if object exists
./bin/objstore exists mykey

# Retrieve only an object's metadata (a flag on get, not a separate command)
./bin/objstore get mykey --metadata

# Lifecycle policy management
# Args: <id> <prefix> <retention-days> <action>  (action: delete or archive)
./bin/objstore policy add cleanup logs/ 30 delete
./bin/objstore policy list
./bin/objstore policy remove cleanup
./bin/objstore policy apply

# Replication management
# Args: <id> <source-backend> <destination-backend>; paths/options via flags
./bin/objstore replication add backup-daily local local \
  --source-path /data/source --dest-path /data/backup --interval 1h
./bin/objstore replication list
./bin/objstore replication trigger backup-daily
./bin/objstore replication status backup-daily

# Health check
./bin/objstore health

# Remote operation (against a running server)
./bin/objstore get mykey --server http://localhost:8080 --server-protocol rest
./bin/objstore get mykey --server localhost:50051 --server-protocol grpc

# Configure via config file, env vars, or flags
./bin/objstore --config .objstore.yaml put mykey data.txt

多协议一体服务器

使用单个二进制文件同时运行所有五个服务器协议：

# Start all services (gRPC, REST, QUIC, Unix socket, MCP)
./bin/objstore-server --quic-self-signed

# Customize ports and addresses
./bin/objstore-server \
  --grpc-addr :50051 \
  --rest-port 8080 \
  --quic-addr :4433 \
  --mcp-addr :8081 \
  --unix --unix-socket /var/run/objstore.sock \
  --quic-self-signed

# Disable specific services
./bin/objstore-server --grpc=false --quic=false

# With production TLS for QUIC
./bin/objstore-server \
  --quic-tls-cert cert.pem \
  --quic-tls-key key.pem

单个服务器二进制文件

针对重点部署分别运行单独的协议：

gRPC服务器：

# Start gRPC server only
./bin/objstore-grpc-server --addr :50051

# With TLS
./bin/objstore-grpc-server --addr :50051 --tls-cert cert.pem --tls-key key.pem

REST API服务器：

# Start REST server only
./bin/objstore-rest-server --port 8080

# Access via HTTP
curl http://localhost:8080/objects/mykey

QUIC/HTTP3服务器：

# Start QUIC server only
./bin/objstore-quic-server -addr :4433 -tlscert cert.pem -tlskey key.pem

# With self-signed certificate (testing only)
./bin/objstore-quic-server -addr :4433 -selfsigned

MCP服务器：

# Start MCP server only (stdio mode for Claude Desktop)
./bin/objstore-mcp-server -mode stdio

# HTTP mode
./bin/objstore-mcp-server -mode http -addr :8081

注：没有独立的Unix套接字服务器二进制文件。Unix套接字服务器只能通过多功能一体机使用 objstore-server --unix 命令。

部署模式

开发-所有服务：

# Quick development setup with all protocols
./bin/objstore-server --quic-self-signed

生产-负载平衡：

# Multiple instances of specific protocols behind load balancers
./bin/objstore-grpc-server --addr :50051 &
./bin/objstore-rest-server --port 8080 &

微服务-专用服务：

# Different protocols in different containers/hosts
docker run objstore-grpc-server
docker run objstore-rest-server
docker run objstore-quic-server

许可证

go objstore在双许可模式下可用：

选项1:GNU Affero通用公共许可证v3.0（AGPL-3.0）

go objstore的开源版本根据 AGPL-3.0.

这是什么意思？

免费使用、修改和分发
非常适合开源项目
如果您修改并部署为网络服务（SaaS），则必须披露您的源代码
衍生作品也必须根据AGPL-3.0获得许可

AGPL-3.0要求，如果您修改此软件并将其作为网络上的服务提供（包括SaaS部署），则必须在相同的许可证下提供修改后的源代码。

选项2：商业许可

如果您希望在没有AGPL-3.0源代码披露要求的情况下在专有软件中使用go-objstore，可以从Automated the Things，LLC获得商业许可证。

商业许可证的好处：

在闭源应用程序中使用
无源代码披露要求
修改并保持更改私有
专业支持和SLA选项
可定制开发
法律保护和赔偿

商业许可联系人：

有关定价和商业许可咨询，请发送电子邮件至licensing@automatethethings.com或访问https://automatethethings.com

看许可证商业.md 了解更多详情。

选择正确的许可证

用例	推荐许可证
开源项目	AGPL-3.0
内部使用与源代码披露	AGPL-3.0
SaaS/云服务（开源）	AGPL-3.0
专有SaaS产品	商业
闭源应用程序	商业
嵌入商业产品	商业
需要专业支持	商业

支持

请考虑支持这个项目，以取得持续的成功和可持续性。我是一名充满激情的开源贡献者，以创造免费、安全、可扩展、健壮、企业级、分布式系统和云原生解决方案为职业。

我也有国际咨询的机会。请让我知道我如何帮助您或您的组织实现所需的安全态势和技术目标。

https://github.com/sponsors/jeremyhahn

https://www.linkedin.com/in/jeremyhahn