Garage

https://garagehq.deuxfleurs.fr/documentation
Admin
Garage is a lightweight, self-hosted S3-compatible object storage system designed for small to...
Tokens:111,619
Snippets:802
Trust Score:8
Update:1 week ago
Show doc for...
Tokens:
Raw
### Install Garage Admin SDK for Golang

Source: https://garagehq.deuxfleurs.fr/documentation/build/golang

Use 'go get' to install the Garage admin SDK for Golang. This command fetches the SDK package from the specified repository.

```bash
go get git.deuxfleurs.fr/garage-sdk/garage-admin-sdk-golang

```

--------------------------------

### Start and enable Garage service

Source: https://garagehq.deuxfleurs.fr/documentation/cookbook/systemd

Commands to start the Garage service and enable it to start at boot. Run these after creating the service file.

```bash
sudo systemctl start garage
sudo systemctl enable garage

```

--------------------------------

### Set up duck for the development cluster

Source: https://garagehq.deuxfleurs.fr/documentation/development/scripts

Sources the environment setup for duck. Duck is not yet provided by nix-shell, so you may need to install it separately. After sourcing, run commands like listing the garage remote or uploading a file.

```bash
source ./script/dev-env-duck.sh

# some examples
duck --list garage:/
duck --upload garage:/eprouvette/ /proc/cpuinfo

```

--------------------------------

### Garage Admin SDK Example in Golang

Source: https://garagehq.deuxfleurs.fr/documentation/build/golang

A comprehensive example demonstrating the Garage admin SDK. It initializes the client, retrieves nodes, modifies the layout, manages keys, and creates/updates buckets. The example uses a local server at 127.0.0.1:3903 and an access token 's3cr3t'.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "strings"
    garage "git.deuxfleurs.fr/garage-sdk/garage-admin-sdk-golang"
)

func main() {
    // Initialization
    configuration := garage.NewConfiguration()
    configuration.Host = "127.0.0.1:3903"
    client := garage.NewAPIClient(configuration)
    ctx := context.WithValue(context.Background(), garage.ContextAccessToken, "s3cr3t")

    // Nodes
    fmt.Println("--- nodes ---")
    nodes, _, _ := client.NodesApi.GetNodes(ctx).Execute()
    fmt.Fprintf(os.Stdout, "First hostname: %v\n", nodes.KnownNodes[0].Hostname)
    capa := int64(1000000000)
    change := []garage.NodeRoleChange{
	    garage.NodeRoleChange{NodeRoleUpdate: &garage.NodeRoleUpdate {
	        Id: *nodes.KnownNodes[0].Id,
	        Zone: "dc1",
	        Capacity: *garage.NewNullableInt64(&capa),
	        Tags: []string{ "fast", "amd64" },
	    }},
    }
    staged, _, _ := client.LayoutApi.AddLayout(ctx).NodeRoleChange(change).Execute()
    msg, _, _ := client.LayoutApi.ApplyLayout(ctx).LayoutVersion(*garage.NewLayoutVersion(staged.Version + 1)).Execute()
    fmt.Printf(strings.Join(msg.Message, "\n")) // Layout configured

    health, _, _ := client.NodesApi.GetHealth(ctx).Execute()
    fmt.Printf("Status: %s, nodes: %v/%v, storage: %v/%v, partitions: %v/%v\n", health.Status, health.ConnectedNodes, health.KnownNodes, health.StorageNodesOk, health.StorageNodes, health.PartitionsAllOk, health.Partitions)

    // Key
    fmt.Println("\n--- key ---")
    key := "openapi-key"
    keyInfo, _, _ := client.KeyApi.AddKey(ctx).AddKeyRequest(garage.AddKeyRequest{Name: *garage.NewNullableString(&key) }).Execute()
    defer client.KeyApi.DeleteKey(ctx).Id(*keyInfo.AccessKeyId).Execute()
    fmt.Printf("AWS_ACCESS_KEY_ID=%s\nAWS_SECRET_ACCESS_KEY=%s\n", *keyInfo.AccessKeyId, *keyInfo.SecretAccessKey.Get())

    id := *keyInfo.AccessKeyId
    canCreateBucket := true
    updateKeyRequest := *garage.NewUpdateKeyRequest()
    updateKeyRequest.SetName("openapi-key-updated")
    updateKeyRequest.SetAllow(garage.UpdateKeyRequestAllow { CreateBucket: &canCreateBucket })
    update, _, _ := client.KeyApi.UpdateKey(ctx).Id(id).UpdateKeyRequest(updateKeyRequest).Execute()
    fmt.Printf("Updated %v with key name %v\n", *update.AccessKeyId, *update.Name)

    keyList, _, _ := client.KeyApi.ListKeys(ctx).Execute()
    fmt.Printf("Keys count: %v\n", len(keyList))

    // Bucket
    fmt.Println("\n--- bucket ---")
    global_name := "global-ns-openapi-bucket"
    local_name := "local-ns-openapi-bucket"
    bucketInfo, _, _ := client.BucketApi.CreateBucket(ctx).CreateBucketRequest(garage.CreateBucketRequest{
        GlobalAlias: &global_name,
        LocalAlias: &garage.CreateBucketRequestLocalAlias {
            AccessKeyId: keyInfo.AccessKeyId,
	    Alias: &local_name,
        },
    }).Execute()
    defer client.BucketApi.DeleteBucket(ctx).Id(*bucketInfo.Id).Execute()
    fmt.Printf("Bucket id: %s\n", *bucketInfo.Id)

    updateBucketRequest := *garage.NewUpdateBucketRequest()
    website := garage.NewUpdateBucketRequestWebsiteAccess()
    website.SetEnabled(true)
    website.SetIndexDocument("index.html")
    website.SetErrorDocument("errors/4xx.html")
    updateBucketRequest.SetWebsiteAccess(*website)
    quotas := garage.NewUpdateBucketRequestQuotas()
    quotas.SetMaxSize(1000000000)
    quotas.SetMaxObjects(999999999)
    updateBucketRequest.SetQuotas(*quotas)
    updatedBucket, _, _ := client.BucketApi.UpdateBucket(ctx).Id(*bucketInfo.Id).UpdateBucketRequest(updateBucketRequest).Execute()
    fmt.Printf("Bucket %v website activation: %v\n", *updatedBucket.Id, *updatedBucket.WebsiteAccess)

    bucketList, _, _ := client.BucketApi.ListBuckets(ctx).Execute()
    fmt.Printf("Bucket count: %v\n", len(bucketList))
}

```

--------------------------------

### Example usage of awscli

Source: https://garagehq.deuxfleurs.fr/documentation/quick-start

Shows example usage of the awscli tool after configuration.

```text
# Example usage of `awscli`

```

--------------------------------

### Full example garage.toml configuration

Source: https://garagehq.deuxfleurs.fr/documentation/reference-manual/configuration

A complete example of a `garage.toml` configuration file showing all available options, including replication, storage paths, database engine, RPC settings, discovery methods, and API endpoints. Use this as a reference when configuring a Garage cluster.

```toml
replication_factor = 3
consistency_mode = "consistent"

metadata_dir = "/var/lib/garage/meta"
data_dir = "/var/lib/garage/data"
metadata_snapshots_dir = "/var/lib/garage/snapshots"
metadata_fsync = true
data_fsync = false
disable_scrub = false
use_local_tz = false
metadata_auto_snapshot_interval = "6h"

db_engine = "lmdb"

block_size = "1M"
block_ram_buffer_max = "256MiB"
block_max_concurrent_reads = 16
block_max_concurrent_writes_per_request =10
lmdb_map_size = "1T"

compression_level = 1

rpc_secret = "4425f5c26c5e11581d3223904324dcb5b5d5dfb14e5e7f35e38c595424f5f1e6"
rpc_bind_addr = "[::]:3901"
rpc_bind_outgoing = false
rpc_public_addr = "[fc00:1::1]:3901"
# or set rpc_public_adr_subnet to filter down autodiscovery to a subnet:
# rpc_public_addr_subnet = "2001:0db8:f00:b00:/64"


allow_world_readable_secrets = false

bootstrap_peers = [
    "563e1ac825ee3323aa441e72c26d1030d6d4414aeb3dd25287c531e7fc2bc95d@[fc00:1::1]:3901",
    "86f0f26ae4afbd59aaf9cfb059eefac844951efd5b8caeec0d53f4ed6c85f332@[fc00:1::2]:3901",
    "681456ab91350f92242e80a531a3ec9392cb7c974f72640112f90a600d7921a4@[fc00:B::1]:3901",
    "212fd62eeaca72c122b45a7f4fa0f55e012aa5e24ac384a72a3016413fa724ff@[fc00:F::1]:3901",
]

allow_punycode = false

[consul_discovery]
api = "catalog"
consul_http_addr = "https://127.0.0.1:8500"
tls_skip_verify = false
service_name = "garage-daemon"

ca_cert = "/etc/consul/consul-ca.crt"
# for `agent` API mode, unset client_cert and client_key:
client_cert = "/etc/consul/consul-client.crt"
client_key = "/etc/consul/consul-key.crt"

# optionally enable `token` for authentication:
# token = "abcdef-01234-56789"

tags = [ "dns-enabled" ]
meta = { dns-acl = "allow trusted" }
datacenters = ["dc1", "dc2", "dc3"]

[kubernetes_discovery]
namespace = "garage"
service_name = "garage-daemon"
skip_crd = false


[s3_api]
api_bind_addr = "[::]:3900"
s3_region = "garage"
root_domain = ".s3.example.com"
advertise_endpoint = "https://s3.example.com"
advertise_path_style = false

[s3_web]
bind_addr = "[::]:3902"
root_domain = ".web.example.com"
add_host_to_metrics = true

[admin]
api_bind_addr = "0.0.0.0:3903"
metrics_token = "BCAdFjoa9G0KJR0WXnHHm7fs1ZAbfpI8iIZ+Z/a2NgI="
metrics_require_token = true
admin_token = "UkLeGWEvHnXBqnueR3ISEMWpOnm40jH2tM2HnnL/0F4="
trace_sink = "http://localhost:4317"

```

--------------------------------

### Install Minio SDK

Source: https://garagehq.deuxfleurs.fr/documentation/build/python

Install the Minio Python SDK using pip.

```bash
pip3 install minio
```

--------------------------------

### Check Nix installation

Source: https://garagehq.deuxfleurs.fr/documentation/development/devenv

Verify that Nix is installed and working by checking the versions of nix-shell, nix-build, and nix-env.

```bash
nix-shell --version
nix-build --version
nix-env   --version

```

--------------------------------

### Install Garage Admin SDK

Source: https://garagehq.deuxfleurs.fr/documentation/build/python

Install the Garage Admin SDK Python package from the git repository. Requires Python 3.6, pip, and setuptools.

```bash
pip3 install --user 'git+https://git.deuxfleurs.fr/garage-sdk/garage-admin-sdk-python'
```

--------------------------------

### Bootstrap a test cluster: start 3 Garage daemons

Source: https://garagehq.deuxfleurs.fr/documentation/development/scripts

Spawns 3 Garage instances with 3 configuration filespawns a simple HTTPS reverse proxy through socat for the S3 endpoint on port 4443. Inspect /tmp/config.1 for detailed configuration (change 1 for instance number). Covers the Launching the garage server section of the Quick start page.

```bash
./script/dev-cluster.sh

```

--------------------------------

### Install Garage on NixOS with nix-shell

Source: https://garagehq.deuxfleurs.fr/documentation/cookbook/binary-packages

Launches a shell with the garage package available using nix-shell.

```shell
nix-shell -p garage

```

--------------------------------

### Admin API example: cluster management

Source: https://garagehq.deuxfleurs.fr/documentation/build/python

Complete example using the Admin API SDK to display node info, change layout, create keys, create buckets, and set quotas. Assumes a fresh Garage instance on localhost with admin API on port 3903 and bearer token 's3cr3t'.

```python
import garage_admin_sdk
from garage_admin_sdk.apis import *
from garage_admin_sdk.models import *

configuration = garage_admin_sdk.Configuration(
  host = "http://localhost:3903/v1",
  access_token = "s3cr3t"
)

# Init APIs
api = garage_admin_sdk.ApiClient(configuration)
nodes, layout, keys, buckets = NodesApi(api), LayoutApi(api), KeyApi(api), BucketApi(api)

# Display some info on the node
status = nodes.get_nodes()
print(f"running garage {status.garage_version}, node_id {status.node}")

# Change layout of this node
current = layout.get_layout()
layout.add_layout([
  NodeRoleChange(
    id = status.node,
    zone = "dc1",
    capacity = 1000000000,
    tags = [ "dev" ],
  )
])
layout.apply_layout(LayoutVersion(
  version = current.version + 1
))

# Create key, allow it to create buckets
kinfo = keys.add_key(AddKeyRequest(name="openapi"))

allow_create = UpdateKeyRequestAllow(create_bucket=True)
keys.update_key(kinfo.access_key_id, UpdateKeyRequest(allow=allow_create))

# Create a bucket, allow key, set quotas
binfo = buckets.create_bucket(CreateBucketRequest(global_alias="documentation"))
binfo = buckets.allow_bucket_key(AllowBucketKeyRequest(
  bucket_id=binfo.id,
  access_key_id=kinfo.access_key_id,
  permissions=AllowBucketKeyRequestPermissions(read=True, write=True, owner=True),
))
binfo = buckets.update_bucket(binfo.id, UpdateBucketRequest(
  quotas=UpdateBucketRequestQuotas(max_size=19029801,max_objects=1500)))

# Display key
print(f"""
cluster ready
key id is {kinfo.access_key_id}
secret key is {kinfo.secret_access_key}
bucket {binfo.global_aliases[0]} contains {binfo.objects}/{binfo.quotas.max_objects} objects
""")
```

--------------------------------

### Check key creation

Source: https://garagehq.deuxfleurs.fr/documentation

List all keys and get info about the nextcloud-app-key to verify it was created properly.

```bash
garage key list
garage key info nextcloud-app-key

```

--------------------------------

### Test website hosting locally with curl

Source: https://garagehq.deuxfleurs.fr/documentation/cookbook/exposing-websites

Prepare a test file, upload it with `mc cp`, then use curl with a Host header to verify the website is served. The first curl uses the bucket name directly, the second uses the bucket name with the root_domain suffix. Both should print 'hello world'.

```bash
# prepare your test
echo hello world > /tmp/index.html
mc cp /tmp/index.html garage/garagehq.deuxfleurs.fr

curl -H 'Host: garagehq.deuxfleurs.fr' http://localhost:3902
# should print "hello world"

curl -H 'Host: garagehq.deuxfleurs.fr.web.example.com' http://localhost:3902
# should also print "hello world"

```

--------------------------------

### Install Garage on Alpine Linux with apk

Source: https://garagehq.deuxfleurs.fr/documentation/cookbook/binary-packages

Installs the garage package from Alpine Linux repositories (available since v3.17). The default configuration file is installed to /etc/garage/garage.toml, and the service can be started with rc-service garage start. If rpc_secret is not specified, it is automatically replaced with a random string on first start. This package is built without Consul discovery, Kubernetes discovery, OpenTelemetry exporter, and K2V features.

```shell
apk add garage

```

--------------------------------

### Output of garage status on a fresh cluster

Source: https://garagehq.deuxfleurs.fr/documentation

Example output of garage status when starting a cluster without automatic configuration. Shows a node with no role assigned.

```text
==== HEALTHY NODES ====
ID                Hostname  Address         Tags  Zone  Capacity          DataAvail  Version
563e1ac825ee3323  linuxbox  127.0.0.1:3901              NO ROLE ASSIGNED             v2.4.1

```

--------------------------------

### Set up minio-client (mc) for the development cluster

Source: https://garagehq.deuxfleurs.fr/documentation/development/scripts

Sources the environment setup for minio-client. After sourcing, run commands like listing the garage alias or copying a file to the eprouvette bucket.

```bash
source ./script/dev-env-mc.sh

# some examples
mc ls garage/
mc cp /proc/cpuinfo garage/eprouvette/cpuinfo.txt

```

--------------------------------

### GET /check - Public bucket domain checks

Source: https://garagehq.deuxfleurs.fr/documentation/reference-manual/admin-api

For a public 'example.com' bucket (name in the global namespace, website activated), the endpoint returns 200 for example.com.s3.garage.localhost, example.com, and example.com.web.garage.localhost. This example assumes s3_api.root_domain = .s3.garage.localhost and s3_web.root_domain = .web.garage.localhost.

```bash
$ curl -so /dev/null -w "%{http_code}" http://localhost:3903/check?domain=example.com.s3.garage.localhost
200
$ curl -so /dev/null -w "%{http_code}" http://localhost:3903/check?domain=example.com
200
$ curl -so /dev/null -w "%{http_code}" http://localhost:3903/check?domain=example.com.web.garage.localhost
200
```

--------------------------------

### GET /check - Private bucket domain checks

Source: https://garagehq.deuxfleurs.fr/documentation/reference-manual/admin-api

For a private 'media' bucket (name in the global namespace, website disabled), the endpoint returns 200 for media.s3.garage.localhost, and 400 for media and media.web.garage.localhost. This example assumes s3_api.root_domain = .s3.garage.localhost and s3_web.root_domain = .web.garage.localhost.

```bash
$ curl -so /dev/null -w "%{http_code}" http://localhost:3903/check?domain=media.s3.garage.localhost
200
$ curl -so /dev/null -w "%{http_code}" http://localhost:3903/check?domain=media
400
$ curl -so /dev/null -w "%{http_code}" http://localhost:3903/check?domain=media.web.garage.localhost
400
```

--------------------------------

### Set up AWS credentials and copy Nix build outputs to S3 cache

Source: https://garagehq.deuxfleurs.fr/documentation/development/miscellaneous-notes

Creates an AWS credentials file in ~/.awsrc, sources it, then builds and copies Nix store paths (including outputs and shell dependencies) to an S3 cache at garage.deuxfleurs.fr.

```bash
cat > $HOME/.awsrc <<EOF
export AWS_ACCESS_KEY_ID="xxx"
export AWS_SECRET_ACCESS_KEY="xxx"
EOF

# source each time you want to send on the cache
source ~/.awsrc

# copy garage build dependencies (and not only the output)
nix-build
nix-store -qR --include-outputs $(nix-instantiate default.nix) 
  | xargs nix copy --to 's3://nix?endpoint=garage.deuxfleurs.fr&region=garage'
  
# copy shell dependencies
nix-build shell.nix -A inputDerivation
nix copy $(nix-store -qR result/) --to 's3://nix?endpoint=garage.deuxfleurs.fr&region=garage' 

```

--------------------------------

### GET /health - Curl request and response

Source: https://garagehq.deuxfleurs.fr/documentation/reference-manual/admin-api

Returns 200 OK if enough nodes are up to have a quorum (ie. serve requests), otherwise returns 503 Service Unavailable. The example shows a curl request to http://localhost:3903/health and the HTTP response with the message 'Garage is fully operational'.

```bash
$ curl -i http://localhost:3903/health
HTTP/1.1 200 OK
content-type: text/plain
content-length: 102
date: Tue, 08 Aug 2023 07:22:38 GMT

Garage is fully operational
Consult the full health check API endpoint at /v2/GetClusterHealth for more details
```

--------------------------------

### GET /metrics - Curl request and Prometheus metrics response

Source: https://garagehq.deuxfleurs.fr/documentation/reference-manual/admin-api

Returns internal Garage metrics in Prometheus format. The metrics are directly documented when returned by the API. The example shows a curl request to http://localhost:3903/metrics and the HTTP response headers followed by sample metric lines.

```bash
$ curl -i http://localhost:3903/metrics
HTTP/1.1 200 OK
content-type: text/plain; version=0.0.4
content-length: 12145
date: Tue, 08 Aug 2023 07:25:05 GMT

# HELP api_admin_error_counter Number of API calls to the various Admin API endpoints that resulted in errors
# TYPE api_admin_error_counter counter
api_admin_error_counter{api_endpoint="CheckWebsiteEnabled",status_code="400"} 1
api_admin_error_counter{api_endpoint="CheckWebsiteEnabled",status_code="404"} 3
# HELP api_admin_request_counter Number of API calls to the various Admin API endpoints
# TYPE api_admin_request_counter counter
api_admin_request_counter{api_endpoint="CheckWebsiteEnabled"} 7
api_admin_request_counter{api_endpoint="Health"} 3
# HELP api_admin_request_duration Duration of API calls to the various Admin API endpoints
...
```

--------------------------------

### Create Garage bucket and enable website access

Source: https://garagehq.deuxfleurs.fr/documentation/connect/repositories

Commands to create a key, bucket, allow access, and enable website access for a Nix repository.

```bash
garage key create nix-key
garage bucket create nix.example.com
garage bucket allow nix.example.com --read --write --key nix-key
garage bucket website nix.example.com --allow

```

--------------------------------

### Enable Garage single-node mode in Helm values

Source: https://garagehq.deuxfleurs.fr/documentation/cookbook/kubernetes

Set garage.singleNode to true in your values file to enable automatic single-node setup. This starts Garage with --single-node, runs one StatefulSet replica, and sets replication_factor = 1. It is intended for new single-node deployments and will refuse to run if the cluster already has a multi-node layout.

```yaml
garage:
  singleNode: true

```

--------------------------------

### Build k2v-cli CLI utility from source

Source: https://garagehq.deuxfleurs.fr/documentation/reference-manual/k2v

Clone the Garage repository, navigate to the k2v-client directory, and build the CLI binary with the cli feature. The CLI is self-documented; run k2v-cli --help for usage.

```bash
git clone https://git.deuxfleurs.fr/Deuxfleurs/garage.git
cd garage/src/k2v-client
cargo build --features cli --bin k2v-cli

```

--------------------------------

### Minio client common commands

Source: https://garagehq.deuxfleurs.fr/documentation/connect/cli

Example commands for listing buckets, listing objects, copying files to and from Garage, and mirroring a folder.

```bash
# list buckets
mc ls garage/

# list objects in a bucket
mc ls garage/my_files

# copy from your filesystem to garage
mc cp /proc/cpuinfo garage/my_files/cpuinfo.txt

# copy from garage to your filesystem
mc cp garage/my_files/cpuinfo.txt /tmp/cpuinfo.txt

# mirror a folder from your filesystem to garage
mc mirror --overwrite ./book garage/garagehq.deuxfleurs.fr

```

--------------------------------

### Build with Nix

Source: https://garagehq.deuxfleurs.fr/documentation/development/devenv

Build the project using Nix with the default parameters.

```bash
nix-build

```

--------------------------------

### Set up s3cmd for the development cluster

Source: https://garagehq.deuxfleurs.fr/documentation/development/scripts

Sources the environment setup for s3cmd. After sourcing, run commands like listing buckets or uploading a file to the eprouvette bucket.

```bash
source ./script/dev-env-s3cmd.sh

# some examples
s3cmd ls
s3cmd put /proc/cpuinfo s3://eprouvette/cpuinfo.txt

```

--------------------------------

### Install mod_s3_upload module

Source: https://garagehq.deuxfleurs.fr/documentation/connect/apps

Install the mod_s3_upload module from the ejabberd-contrib repository using ejabberdctl.

```bash
ejabberdctl module_install mod_s3_upload

```

--------------------------------

### Install Garage on FreeBSD with pkg

Source: https://garagehq.deuxfleurs.fr/documentation/cookbook/binary-packages

Installs the garage package using the FreeBSD package manager.

```shell
pkg install garage

```

--------------------------------

### Create Garage buckets for Peertube

Source: https://garagehq.deuxfleurs.fr/documentation/connect/apps

Creates two buckets: 'peertube-videos' for normal videos and 'peertube-playlists' for webtorrent videos.

```bash
garage bucket create peertube-videos
garage bucket create peertube-playlists

```

--------------------------------

### Create Garage key and bucket for Vector system logs

Source: https://garagehq.deuxfleurs.fr/documentation/connect/observability

Run these Garage CLI commands to create a key and bucket for storing system logs, and allow the key to read and write to the bucket.

```bash
garage key create vector-system-logs
garage bucket create system-logs
garage bucket allow system-logs --read --write --key vector-system-logs

```

--------------------------------

### Make cluster instances join: assign zone and weight

Source: https://garagehq.deuxfleurs.fr/documentation/development/scripts

Configures each instance by assigning a zone (dc1) and a weight (1). Covers the Creating a cluster layout section of the Quick start page.

```bash
./script/dev-configure.sh

```

--------------------------------

### Install Garage with pixi from conda-forge

Source: https://garagehq.deuxfleurs.fr/documentation/cookbook/binary-packages

Installs the garage package globally using pixi from the conda-forge channel.

```shell
pixi global install garage

```

--------------------------------

### Install awscli with pip

Source: https://garagehq.deuxfleurs.fr/documentation

Install awscli using Python's package manager. Requires Python on your system.

```bash
python -m pip install --user awscli
```

--------------------------------

### Generate initial configuration file with garage.toml

Source: https://garagehq.deuxfleurs.fr/documentation

Creates a minimal Garage configuration file with metadata and data directories, SQLite engine, replication factor 1, RPC settings, S3 API, S3 web, and admin sections. Uses openssl to generate secrets. Note that data in /tmp is not persistent.

```bash
cat > garage.toml <<EOF
metadata_dir = "/tmp/meta"
data_dir = "/tmp/data"
db_engine = "sqlite"

replication_factor = 1

rpc_bind_addr = "[::]:3901"
rpc_public_addr = "127.0.0.1:3901"
rpc_secret = "$(openssl rand -hex 32)"

[s3_api]
s3_region = "garage"
api_bind_addr = "[::]:3900"
root_domain = ".s3.garage.localhost"
advertise_endpoint = "http://s3.garage.localhost:3900"

[s3_web]
bind_addr = "[::]:3902"
root_domain = ".web.garage.localhost"
index = "index.html"

[admin]
api_bind_addr = "[::]:3903"
admin_token = "$(openssl rand -base64 32)"
metrics_token = "$(openssl rand -base64 32)"
EOF

```

--------------------------------

### Install Garage on Arch Linux with pacman

Source: https://garagehq.deuxfleurs.fr/documentation/cookbook/binary-packages

Installs the garage package from the official Arch Linux repositories under extra.

```shell
pacman -S garage

```

--------------------------------

### Check Rust installation

Source: https://garagehq.deuxfleurs.fr/documentation/development/devenv

Verify that the Rust toolchain is installed and working by checking versions of rustc, cargo, rustfmt, and clippy-driver.

```bash
rustc --version
cargo --version
rustfmt --version
clippy-driver --version

```

--------------------------------

### Install C toolchain on Debian

Source: https://garagehq.deuxfleurs.fr/documentation/cookbook/from-source

Installs the build-essential package to provide a full C toolchain required for building Garage.

```bash
sudo apt-get update
sudo apt-get install build-essential

```

--------------------------------

### Set up awscli for the development cluster

Source: https://garagehq.deuxfleurs.fr/documentation/development/scripts

Sources the environment setup for awscli. After sourcing, run commands like listing the eprouvette bucket or copying a file to it.

```bash
source ./script/dev-env-aws.sh

# some examples
aws s3 ls s3://eprouvette
aws s3 cp /proc/cpuinfo s3://eprouvette/cpuinfo.txt

```

--------------------------------

### Install optional nix.conf

Source: https://garagehq.deuxfleurs.fr/documentation/development/devenv

Optionally copy the provided nix.conf to /etc/nix and restart the nix-daemon to speed up compilations.

```bash
sudo mkdir -p /etc/nix
sudo cp nix/nix.conf /etc/nix/nix.conf
sudo killall nix-daemon

```
Tokens:
Raw