Wasabi Academy

https://docs.wasabi.com/docs
Admin
Wasabi Academy is a comprehensive documentation platform providing guides, tutorials, and resources...
Tokens:140,713
Snippets:733
Trust Score:10
Update:1 year ago
Show doc for...
Tokens:
Raw
### Start FineUploader PHP Server with Wasabi Credentials

Source: https://docs.wasabi.com/docs/how-do-i-use-fineuploader-with-wasabi

Configures and starts a local PHP server for FineUploader, setting environment variables for Wasabi access keys and bucket name. This script is essential for running the example.

```bash
#!/bin/bash
export AWS_SERVER_PUBLIC_KEY=YOUR_PUBLIC_ACCESS_KEY
export AWS_SERVER_PRIVATE_KEY=YOUR_SECRET_KEY
export AWS_CLIENT_SECRET_KEY=$AWS_SERVER_PRIVATE_KEY
export S3_BUCKET_NAME=YOUR_BUCKET_NAME
php -S 0.0.0.0:8080
```

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

### Start ClarityNow Service

Source: https://docs.wasabi.com/docs/how-do-i-use-dells-claritynow-dataiq-with-wasabi

Starts the ClarityNow system service. This command should be executed after the AWS SDK has been installed and credentials have been configured.

```shell
systemctl start claritynow

```

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

### Install FineUploader JavaScript Library

Source: https://docs.wasabi.com/docs/how-do-i-use-fineuploader-with-wasabi

Installs the FineUploader JavaScript library using npm. This is a prerequisite for the client-side upload functionality.

```bash
mkdir fineuploader-example
cd fineuploader-example
echo "{}" > package.json
npm install fine-uploader
```

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

### Install AWS SDK for ClarityNow

Source: https://docs.wasabi.com/docs/how-do-i-use-dells-claritynow-dataiq-with-wasabi

Installs the necessary AWS SDK package required for Wasabi's S3 scanning functionality in ClarityNow. This is a prerequisite before running the ClarityNow daemon.

```shell
rpm -ivh aws-sdk-1.1.221-0.x86_64

```

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

### Configure FineUploader PHP Backend with Composer

Source: https://docs.wasabi.com/docs/how-do-i-use-fineuploader-with-wasabi

Sets up the PHP backend for FineUploader using Composer to handle server-side requests like signature generation. Requires Composer to be installed.

```bash
vim composer.json
# Add the following JSON to composer.json:
# {"require": {"fineuploader/php-s3-server": "1.1.0"}}
./composer.phar install
```

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

### Create Directory for NFS Uploads

Source: https://docs.wasabi.com/docs/getting-started-3

This command creates a new directory named 'mystuff' under the '/Volume1/wasabi' mount point. Any data copied into this directory will be uploaded to the specified bucket on the Wasabi Ball appliance.

```shell
mkdir /Volume1/wasabi/mystuff
```

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

### Start Backup Process (CLI)

Source: https://docs.wasabi.com/docs/how-do-i-use-superna-golden-copy-with-wasabi

Initiates the backup process for a specified folder ID managed by Superna Golden Copy. The ID should correspond to a previously added folder.

```bash
searchctl archivedfolders archive --id
```

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

### Start nginx Server (Bash)

Source: https://docs.wasabi.com/docs/setting-up-nginx-to-proxy-authentication-requests-to-wasabi

Starts the nginx web server after configuration changes. This command assumes nginx was installed in the default location.

```bash
# sudo /usr/local/nginx/sbin/nginx 
```

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

### movedat Command-Line File Transfer Examples

Source: https://docs.wasabi.com/docs/how-to-use-clouddat-with-wasabi

This snippet demonstrates various file transfer operations using the 'movedat' command-line client. It covers uploading, downloading, renaming, deleting, and listing files on a Wasabi bucket via CloudDat.

```bash
movedat local.dat s3user@wasabi.example.com=S3:remote.dat
```

```bash
movedat s3user@wasabi.example.com=S3:remote.dat local.dat
```

```bash
movedat -m s3user@wasabi.example.com=S3:remote.dat newremote.dat
```

```bash
movedat -x s3user@wasabi.example.com=S3:newremote.dat
```

```bash
movedat s3user@wasabi.com=S3: 
movedat s3user@wasabi.example.com=S3:subdir/
```

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

### Install Django

Source: https://docs.wasabi.com/docs/how-do-i-use-django-with-wasabi-s3

Installs the Django web framework using pip. This is the first step in setting up a new Django project.

```shell
pip install django
```

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

### Install s3ql on Ubuntu

Source: https://docs.wasabi.com/docs/how-do-i-use-s3ql-with-wasabi

Installs the s3ql package on Ubuntu systems using aptitude. This is a prerequisite for using s3ql with cloud storage.

```bash
sudo apt-get install aptitude
sudo aptitude install s3ql
```

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

### SSH Connection to Wasabi Ball Appliance

Source: https://docs.wasabi.com/docs/getting-started-3

Demonstrates how to establish an SSH connection to the Wasabi Ball appliance using provided credentials. This is the first step to access the appliance's command line interface for configuration.

```shell
wasabi$ ssh root@Ip_Address
username's password:
Welcome to ReadyNASOS 6.10.0
Last login: Tue May 7 11:02:11 2019 from 10.6.140.8
root@wasabiball34:~# 
```

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

### Install ClickHouse Server and Client on Ubuntu

Source: https://docs.wasabi.com/docs/clickhouse-with-wasabi

This script installs the ClickHouse server and client packages on Ubuntu systems. It adds the ClickHouse repository, updates the package list, installs the packages, and starts the server.

```bash
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv E0C56BD4
echo "deb https://packages.clickhouse.com/deb stable main" | sudo tee /etc/apt/sources.list.d/clickhouse.list
sudo apt update
sudo apt install clickhouse-server clickhouse-client -y
sudo systemctl start clickhouse-server
```

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

### Install Goofys Utility

Source: https://docs.wasabi.com/docs/how-do-i-use-goofys-with-wasabi

Commands to install the Goofys utility using Go. This requires Go to be installed and configured on your system. The commands set the GOPATH, download the goofys package, and then install it.

```shell
$ export GOPATH=$HOME/work
$ go get github.com/kahing/goofys
$ go install github.com/kahing/goofys
```

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

### Python SDK Integration Example

Source: https://context7.com/context7/wasabi/llms.txt

A comprehensive Python example using the boto3 SDK to demonstrate common Wasabi S3 operations, including bucket management, object handling, and error management.

```APIDOC
## Wasabi S3 Client Initialization

### Description
This section provides a Python code snippet demonstrating how to initialize a `boto3` S3 client specifically configured for Wasabi's S3-compatible storage.

### Method
N/A (Code Example)

### Endpoint
N/A (Code Example)

### Parameters
#### Request Body
N/A

#### Environment Variables / Configuration
- **AWS_ACCESS_KEY_ID**: Your Wasabi access key ID.
- **AWS_SECRET_ACCESS_KEY**: Your Wasabi secret access key.
- **AWS_REGION**: The Wasabi region (e.g., 'us-east-1', 'eu-central-1').

### Request Example
```python
import boto3
from botocore.exceptions import ClientError, NoCredentialsError
import logging

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Initialize Wasabi S3 client
def create_wasabi_client(region='us-east-1'):
    """Create boto3 S3 client configured for Wasabi"""
    try:
        client = boto3.client(
            's3',
            endpoint_url=f'https://s3.{region}.wasabisys.com',
            aws_access_key_id='AKIAIOSFODNN7EXAMPLE', # Replace with your Wasabi Access Key ID
            aws_secret_access_key='wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY', # Replace with your Wasabi Secret Access Key
            region_name=region
        )
        logger.info(f"Successfully created Wasabi S3 client for region: {region}")
        return client
    except NoCredentialsError:
        logger.error("AWS credentials not found. Please configure your Wasabi credentials.")
        return None
    except Exception as e:
        logger.error(f"An error occurred while creating the Wasabi client: {e}")
        return None

# Example Usage:
# wasabi_client = create_wasabi_client('us-west-1')
# if wasabi_client:
#     # Proceed with S3 operations
#     pass
```

### Response
#### Success Response (Client Object)
- Returns a `boto3` S3 client object configured for Wasabi.

#### Error Response
- Returns `None` if credentials are not found or if any other exception occurs during client creation.
```

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

### Example Custom SQL Query for Wasabi Objects

Source: https://docs.wasabi.com/docs/how-do-i-use-the-cdata-wasabi-tableau-connector-with-my-wasabi-storage

This SQL query demonstrates how to retrieve all items within a specific Wasabi bucket. It requires the bucket name as a parameter. This is useful for analyzing the contents of individual buckets.

```sql
SELECT * FROM OBJECTS WHERE Bucket = 'mybucket';
```

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

### Install s4cmd using pip

Source: https://docs.wasabi.com/docs/how-do-i-use-s4cmd-with-wasabi

This snippet shows how to install the s4cmd utility using the pip package installer. Ensure pip is installed and accessible in your environment.

```bash
pip install s4cmd
```

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

### Start OpenSearch and Register Wasabi Snapshot Repository

Source: https://docs.wasabi.com/docs/how-do-i-use-opensearch-with-wasabi

These commands start the OpenSearch service and register a Wasabi S3 bucket as a snapshot repository. The registration process involves a PUT request to the OpenSearch API, specifying the repository type, bucket name, and base path.

```shell
./opensearch-tar-install.sh

```

```shell
curl -X GET http://localhost:9200

```

```shell
curl -XPUT "http://localhost:9200/_snapshot/<repository-name> " -H 'Content-Type: application/json' -d'
{
  "type": "s3",
  "settings": {
    "bucket": "<bucket-name>",
    "base_path": “<base path or object prefix>"
  }
}'

```

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

### s3ql Backend Credentials Prompt

Source: https://docs.wasabi.com/docs/how-do-i-use-s3ql-with-wasabi

Example of the prompts encountered when mounting an s3ql file system with Wasabi, requesting backend login, passphrase, and optional encryption password.

```text
Enter backend login: 
Enter backend passphrase: 
Enter encryption password:   //Optional, Can leave it blank
Confirm encryption password: 
```

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

### Install Build Dependencies (Bash)

Source: https://docs.wasabi.com/docs/setting-up-nginx-to-proxy-authentication-requests-to-wasabi

Installs essential development packages required for compiling software from source, such as nginx. These include build-essential, PCRE development libraries, zlib development libraries, and OpenSSL development libraries.

```bash
# sudo apt-get install build-essential libpcre3-dev zlib1g-dev libssl-dev -y 
```

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

### Set Static IP Address via Command Line (Linux)

Source: https://docs.wasabi.com/docs/getting-started-3

This command configures a static IP address for the eth2 interface on the Wasabi Ball appliance. This configuration is temporary and will not persist after a reboot. It requires SSH access to the appliance.

```shell
ifconfig eth2 10.1.1.1 netmask 255.255.255.0
```

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

### Install HTTPie Client

Source: https://docs.wasabi.com/docs/how-do-i-use-elasticsearch-with-wasabi

Installs the HTTPie command-line HTTP client, which is used for making local HTTP requests to Elasticsearch. This tool simplifies testing and interacting with Elasticsearch APIs.

```bash
$ sudo snap install http
```

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

### Install django-storages

Source: https://docs.wasabi.com/docs/how-do-i-use-django-with-wasabi-s3

Installs the django-storages library, which provides support for various storage backends, including S3.

```shell
pip install django-storages
```

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

### Verify Django Installation

Source: https://docs.wasabi.com/docs/how-do-i-use-django-with-wasabi-s3

Runs the django-admin command to confirm that Django has been successfully installed and to view available sub-commands.

```shell
django-admin

Type 'django-admin help ' for help on a specific subcommand.

Available subcommands:

[django]
    check
    compilemessages
    createcachetable
    dbshell
    diffsettings
    dumpdata
    flush
    inspectdb
    loaddata
    makemessages
    makemigrations
    migrate
    runserver
    sendtestemail
    shell
    showmigrations
    sqlflush
    sqlmigrate
    sqlsequencereset
    squashmigrations
    startapp
    startproject
    test
    testserver
```

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

### Install CTE Agent Binary on RHEL

Source: https://docs.wasabi.com/docs/how-to-use-thales-cte-with-wasabi

This command installs the CTE agent on a RHEL instance. Ensure you have the correct binary file path. This step requires root privileges.

```bash
./vee-fs-7.3.0-135-rh8-x86_64.bin
```

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

### Calculate Monthly Storage Cost (Example)

Source: https://docs.wasabi.com/docs/how-do-i-interpret-the-charges-on-my-pay-go-pricing-model-invoice

This example demonstrates how to calculate the monthly cost of storage based on the per GB per day unit price and the monthly minimum storage volume. It shows the calculation for Timed Active Storage and the potential Minimum Active Storage Charge.

```text
Unit Price per GB per day: $0.00022754

Calculation for $/TB/mo:
$0.00022754/GB/day * 30 days/mo * 1024 GB/TB = $6.99/TB/mo

Monthly Minimum Storage Volume = 1 TB (1024 GB) = $6.99

Example Scenario:
Amount of Timed Active Storage = 750 GB
Charge for Timed Active Storage = 750 GB * $0.00022754/GB/day * 30 days/mo = $5.12

Minimum Active Storage Charge applies if Timed Active Storage < Monthly Minimum Storage Volume.

Difference in volume = 1 TB - 750 GB = 274 GB
Minimum Active Storage Charge = 274 GB * $0.00022754/GB/day * 30 days/mo = $1.87
```

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

### Install AWS SDK for JavaScript (v3) Packages

Source: https://docs.wasabi.com/docs/how-do-i-use-aws-sdk-for-javascript-v3-with-wasabi

Installs modularized packages for AWS SDK for JavaScript (v3), including clients for IAM, S3, and credential providers. Ensure Node.js is installed and verify with 'node -v'.

```bash
npm install @aws-sdk/client-service
```

```bash
npm install @aws-sdk/client-iam
```

```bash
npm install @aws-sdk/client-s3
```

```bash
npm install @aws-sdk/credential-provider-ini
```

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

### Navigate to Extracted Cydex Folder

Source: https://docs.wasabi.com/docs/how-do-i-use-cydex-with-wasabi

This command changes the current directory to the folder where the Cydex installer was extracted. This is a necessary step before running the installation script.

```bash
cd 

```

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

### Install Globus Connect Server v5.4 on Linux

Source: https://docs.wasabi.com/docs/how-to-use-globus-connect-server-with-wasabi

Installs the Globus Connect Server v5.4 software by adding the Globus repository and then installing the server package. This process requires root privileges for package management and key addition.

```bash
curl -LOs https://downloads.globus.org/globus-connect-server/stable/installers/repo/deb/globus-repo_latest_all.deb
sudo dpkg -i globus-repo_latest_all.deb
sudo apt-key add /usr/share/globus-repo/RPM-GPG-KEY-Globus
sudo apt update
sudo apt install globus-connect-server54
```

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

### Required Values for STS Examples

Source: https://docs.wasabi.com/docs/how-do-i-use-aws-sts-with-wasabi

This snippet defines the static strings which needs to be initialized with valid Wasabi credentials for correct usage of the examples above.

```Java
static String s3Uri = "https://s3.wasabisys.com";
static String stsUri = "https://sts.wasabisys.com";
static String credentialsProfile = "PUT_THE_NAME_OF_YOUR_PROFILE_LOCATED_IN_AWS_CONFIG_FILE";
static String roleArn = "ARN_OF_THE_ROLE_TO_BE_ASSUMED";
```

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

### Example Listing Incomplete Uploads with Minio Client (mc)

Source: https://docs.wasabi.com/docs/how-do-i-clean-up-my-failed-multipart-uploads

This is an example output demonstrating the `mc ls -I` command, showing files marked with `UP/` indicating they are part of an incomplete multi-part upload. The output includes timestamps, sizes, and file paths.

```text
mc ls s3/mikeo-status-test-east -I
[2019-07-23 15:35:21 EDT]      0B UP/10GB-aws.bin
[2019-07-23 16:16:29 EDT]   16MiB UP/10GB-aws.bin
[2019-09-12 17:25:25 EDT]  2.3GiB UP/10GB-aws.bin
[2019-08-04 08:18:56 EDT]   88MiB UP/10GB-aws.bin
[2019-08-20 11:38:40 EDT]  576MiB UP/10GB-aws.bin
[2019-08-24 12:49:12 EDT]  688MiB UP/10GB-aws.bin
[2019-08-04 10:21:37 EDT]  272MiB UP/10GB-packet.bin
[2019-07-18 12:23:42 EDT]   80MiB UP/10GB-packet.bin
[2019-07-23 15:35:25 EDT]      0B UP/10GB-packet.bin
[2019-07-23 16:32:06 EDT]   64MiB UP/10GB-packet.bin
[2019-08-04 08:19:42 EDT]  1.3GiB UP/10GB-packet.bin
[2019-06-05 16:08:51 EDT]      0B UP/10GB.bin
```

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

### Install AWS CLI on Linux

Source: https://docs.wasabi.com/docs/how-to-use-thales-cte-with-wasabi

Commands to download, unzip, and install the AWS Command Line Interface (CLI) version 2 on a Linux system. This is a prerequisite for interacting with Wasabi storage via the command line.

```bash
curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
unzip awscliv2.zip
sudo ./aws/install
```

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

### Install OpenSearch Repository-S3 Plugin and Configure Wasabi

Source: https://docs.wasabi.com/docs/how-do-i-use-opensearch-with-wasabi

This section covers installing the 'repository-s3' plugin for OpenSearch and configuring access to your Wasabi S3 bucket. It involves setting admin passwords, adding Wasabi access and secret keys to the OpenSearch keystore, and modifying the 'opensearch.yml' configuration file.

```shell
./bin/opensearch-plugin install repository-s3

```

```shell
export OPENSEARCH_INITIAL_ADMIN_PASSWORD=<custom-admin-password>

```

```shell
./bin/opensearch-keystore add s3.client.default.access_key

```

```shell
./bin/opensearch-keystore add s3.client.default.secret_key

```

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

### Install iRODS S3 Plugin (Debian/Ubuntu)

Source: https://docs.wasabi.com/docs/how-to-use-irods-with-wasabi

Installs the latest version of the iRODS S3 Plugin on iRODS servers using apt-get. This is a prerequisite for connecting iRODS to S3-compatible storage like Wasabi.

```bash
sudo apt-get install irods-resource-plugin-s3
```

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

### Create and Push Test File to Wasabi

Source: https://docs.wasabi.com/docs/how-do-i-use-splunk-with-wasabi

This snippet demonstrates creating a sample text file and then using Splunk's command-line interface to push it to the configured Wasabi remote storage volume. It includes a verification step using the 'ls' command.

```bash
echo "hello world" > test01.txt
./opt/splunk/bin/splunk cmd splunkd rfs -- putF test01.txt volume:wasabi
./opt/splunk/bin/splunk cmd splunkd rfs -- ls --starts-with volume:wasabi
```

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

### gsutil Commands for Wasabi Bucket Operations

Source: https://docs.wasabi.com/docs/how-do-i-use-gsutil-with-wasabi

These are sample gsutil commands demonstrating common operations like listing bucket contents, uploading a local file to a Wasabi bucket, and downloading a file from a Wasabi bucket to a local directory. Remember to replace placeholders like `s3://bucket-name` and `/path/to/local/file` with your actual bucket names and file paths.

```bash
gsutil ls s3://bucket-name
```

```bash
gsutil cp /path/to/local/file s3://bucket-name/
```

```bash
gsutil cp s3://bucket-name/object-name /path/to/local/directory/
```

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

### Test iRODS File Transfer to Wasabi

Source: https://docs.wasabi.com/docs/how-to-use-irods-with-wasabi

Tests the integration by performing a put and get operation for a file between iRODS and the configured Wasabi resource. This verifies that iRODS can correctly write to and read from the Wasabi bucket.

```bash
$ echo 'this is a test' > test.txt 

$ iput –R wasabiresc1 test.txt 

$ iget test.txt -
```

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

### Initialize Supabase Environment

Source: https://docs.wasabi.com/docs/supabase-postgres-db-with-wasabi

Initializes the Supabase environment for your local project. This command sets up the necessary configuration files for Supabase development.

```bash
supabase init
```

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

### Create s4cmd symbolic link

Source: https://docs.wasabi.com/docs/how-do-i-use-s4cmd-with-wasabi

This command creates a symbolic link to make the s4cmd.py script executable as 's4cmd'. The path provided is an example for Python 3.7 on Linux and may need adjustment based on your system's Python installation.

```bash
ln -s .local/lib/python3.7/site-packages/s4cmd.py s4cmd
```

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

### Take Snapshot of Specific Elasticsearch Index

Source: https://docs.wasabi.com/docs/how-do-i-use-elasticsearch-with-wasabi

This command allows you to take a snapshot of a specific index or a group of indices matching a pattern. The example shows how to snapshot indices starting with 'filebeat-*'. The JSON payload specifies the 'indices' to be included in the snapshot.

```shell
$ echo '{"indices":"filebeat-*"}' | http PUT 127.0.0.1:9200/_snapshot/my_wasabi_repository/filebeat-021021?wait_for_completion=true

```

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

### Create New Django Project

Source: https://docs.wasabi.com/docs/how-do-i-use-django-with-wasabi-s3

Uses the django-admin startproject command to create the basic file structure for a new Django project.

```shell
django-admin startproject 
```

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

### Mount s3ql file system with Wasabi

Source: https://docs.wasabi.com/docs/how-do-i-use-s3ql-with-wasabi

Mounts the s3ql file system to interact with Wasabi cloud storage. This command initializes the file system and prompts for necessary credentials.

```bash
mkfs.s3ql s3c://s3.wasabisys.com:443/
```

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

### Verify IP Address Configuration (Linux)

Source: https://docs.wasabi.com/docs/getting-started-3

After setting a static IP address using ifconfig, this command verifies the assigned IP address and network mask for the eth2 interface. It displays detailed network interface information.

```shell
ifconfig eth2
```

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

### Create IAM User with Wasabi and AWS SDK for Go

Source: https://docs.wasabi.com/docs/how-do-i-use-aws-sdk-for-go-golang-with-wasabi

This Go program demonstrates creating an IAM user using the AWS SDK for Go and Wasabi's IAM endpoint. It first establishes a connection to the Wasabi IAM endpoint, similar to the connection example. It then calls the `CreateUser` API with a specified username and prints the name of the newly created user upon success.

```go
package main

import (
"context"
"fmt"
"log"

"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/service/iam"
)

func main() {
cfg, err := config.LoadDefaultConfig(context.TODO(),
config.WithRegion("us-east-1"),
config.WithEndpointResolverWithOptions(
aws.EndpointResolverWithOptionsFunc(
func(service, region string, options ...interface{}) (aws.Endpoint, error) {
if service == iam.ServiceID {
return aws.Endpoint{
URL: "https://iam.wasabisys.com",
SigningRegion: "us-east-1",
},
nil
}
return aws.Endpoint{}, &aws.EndpointNotFoundError{}
},
),
),
)
if err != nil {
log.Fatalf("unable to load SDK config, %v", err)
}

iamClient := iam.NewFromConfig(cfg)

userName := "iam-user-name"

createUserOutput, err := iamClient.CreateUser(context.TODO(), &iam.CreateUserInput{
UserName: &userName,
})
if err != nil {
log.Fatalf("Unable to create IAM user: %v", err)
}

fmt.Printf("Created user: %s\n", aws.ToString(createUserOutput.User.UserName))
}
```

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

### Launch Aspera HST Server

Source: https://docs.wasabi.com/docs/how-do-i-use-ibm-aspera-with-wasabi

This command launches the IBM Aspera High-Speed Transfer Server (HST Server) GUI with root privileges. This is the initial step to access the server's configuration interface for setting up users and storage locations.

```bash
# asperascp
```

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

### Make Authenticated API Request using curl

Source: https://docs.wasabi.com/docs/wacm-connect-api-authentication

This example demonstrates how to make a GET request to the WACM Connect API using curl, including the necessary Authorization header with a pre-encoded base64 string. It ensures secure communication over HTTPS and authenticates the request with the provided credentials.

```Bash
curl -X GET https://api.wacm.wasabisys.com/resource \
  -H "Authorization: Basic dXNlcm5hbWU6YXBpa2V5MTIzNDU2"
```

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

### Creating a Bucket

Source: https://docs.wasabi.com/docs/dell-objectscale-getting-started

This section details how to create an S3 bucket using Postman by sending a PUT request to the specified endpoint.

```APIDOC
## PUT /{{bucketname}}

### Description
Creates a new S3 bucket.

### Method
PUT

### Endpoint
`https://s3.us-east-1-dell-obs.wasabisys.com:9021/{{bucketname}}`

### Parameters
#### Path Parameters
- **bucketname** (string) - Required - The desired name for the bucket.

#### Query Parameters
None

#### Request Body
None

### Request Example
None (Request is configured via Postman UI)

### Response
#### Success Response (200)
- **status** (string) - Indicates success.

#### Response Example
```json
{
  "status": "Bucket created successfully."
}
```
```

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

### Get Latest DataSync AMI using AWS CLI

Source: https://docs.wasabi.com/docs/how-do-i-transfer-data-from-aws-to-wasabi-using-aws-datasync

Retrieves the latest Amazon Machine Image (AMI) ID for the DataSync agent in a specified AWS region using the AWS Systems Manager Parameter Store. This command requires the AWS CLI to be installed and configured.

```bash
aws ssm get-parameter --name /aws/service/datasync/ami --region region
```

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

### Create New Laravel Project with Composer

Source: https://docs.wasabi.com/docs/how-do-i-use-laravel-with-wasabi

This command initiates a new Laravel project using Composer, the dependency manager for PHP. Ensure Composer is installed and accessible in your system's PATH.

```bash
composer create-project laravel/laravel 

```

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

### OIDC Role Example for SSO Legacy

Source: https://docs.wasabi.com/docs/creating-a-role

This code snippet illustrates the configuration for an OpenID Connect (OIDC) role in Wasabi for legacy SSO setups. It requires your root user account ID and your Identity Provider (IDP) ID. Verify that the policy code adheres to OIDC standards.

```json
{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "Federated": "arn:aws:iam::<RootUserAcctID>:oidc-provider/<IDP>"
      },
      "Action": "sts:AssumeRoleWithWebIdentity",
      "Condition": {
        "StringEquals": {
          "oidc:aud": "<IDP>"
        }
      }
    }
  ]
}
```

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

### Example User Policy for Specific Bucket Access (JSON)

Source: https://docs.wasabi.com/docs/creating-a-policy

This JSON policy allows a specific user, Alice, to perform various S3 operations (list, get, put, delete objects) on a bucket named 'bucket1' and its contents. It defines granular access control for individual users.

```json
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllowAccessToBucketNamedBucket1", "Effect": "Allow",
"Action": [
"s3:ListBucket", "s3:GetObject", "s3:PutObject", "s3:GetObjectAcl", "s3:PutObjectAcl", "s3:DeleteObject" ],
"Resource": [ "arn:aws:s3:::bucket1", "arn:aws:s3:::bucket1/*" ]
}
]
}
```

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

### Validate Elasticsearch S3 Plugin Installation

Source: https://docs.wasabi.com/docs/how-do-i-use-elasticsearch-with-wasabi

Lists all installed Elasticsearch plugins to verify that the 'repository-s3' plugin has been successfully installed and is recognized by Elasticsearch.

```bash
$ sudo /usr/share/elasticsearch/bin/elasticsearch-plugin list
```

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

### Connect to Wasabi IAM Endpoint using AWS SDK C++

Source: https://docs.wasabi.com/docs/how-do-i-use-aws-sdk-for-cpp-with-wasabi

This C++ code shows how to connect to the Wasabi IAM service endpoint using the AWS SDK for C++ (v1). It configures the client with a specific endpoint override and uses credentials from a specified profile. The example attempts to get the current user to verify the connection.

```cpp
#include <aws/core/Aws.h>
#include <aws/core/auth/AWSCredentialsProvider.h>
#include <aws/core/client/ClientConfiguration.h>
#include <aws/iam/IAMClient.h>
#include <aws/iam/model/GetUserRequest.h>
#include <aws/iam/model/GetUserResult.h>
#include <iostream>
#include <memory>

int main() {

    Aws::SDKOptions options;
    Aws::InitAPI(options);
    {

        const Aws::String profileName = "wasabi";
        Aws::Client::ClientConfiguration clientConfig;
        clientConfig.endpointOverride = "https://iam.wasabisys.com";
        auto credentialsProvider = std::make_shared<Aws::Auth::ProfileConfigFileAWSCredentialsProvider>(profileName.c_str());
        Aws::IAM::IAMClient iamClient(credentialsProvider, clientConfig);

       // Test by using the current user, don't remember the username

        Aws::IAM::Model::GetUserRequest request;
        auto outcome = iamClient.GetUser(request);

        if (outcome.IsSuccess()) {
            std::cout << "Connection successful" << std::endl;
        } else {
            std::cerr << "Connection failed: " << outcome.GetError().GetMessage() << std::endl;
        }
    }

    Aws::ShutdownAPI(options);
    return 0;
}
```

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

### List Available OpenSearch Snapshots

Source: https://docs.wasabi.com/docs/how-do-i-use-opensearch-with-wasabi

This command lists all available snapshots within a specified repository. It requires the base path and repository name to match the initial configuration. Ensure the OpenSearch server is running and accessible.

```shell
curl -XGET "http://localhost:9200/_snapshot/<repository-name>/_all"
```

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

### Get Latest DataSync AMI using PowerShell

Source: https://docs.wasabi.com/docs/how-do-i-transfer-data-from-aws-to-wasabi-using-aws-datasync

Retrieves the latest Amazon Machine Image (AMI) ID for the DataSync agent in a specified AWS region using the AWS Systems Manager Parameter Store via PowerShell. This example demonstrates how to execute the AWS CLI command within a PowerShell script.

```powershell
$ aws ssm get-parameter --name /aws/service/datasync/ami --region us-east-1
```

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

### Configure GeeseFS Mount in /etc/fstab

Source: https://docs.wasabi.com/docs/how-do-i-use-geesefs-with-wasabi

An example entry for /etc/fstab to automatically mount a Wasabi S3 bucket using GeeseFS upon system boot or via 'mount -a'. Includes essential mount options.

```bash
geesefs-bucket /mnt/geesefs fuse.geesefs _netdev,allow_other,--file-mode=0666,--dir-mode=0777,--list-type=1,--region=us-east-1,--endpoint=s3.us-east-1.wasabisys.com,--profile=geesefs 0 0
```

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

### Run Minio Container for On-Premise Storage

Source: https://docs.wasabi.com/docs/how-do-i-use-flexifyio-with-wasabi

This command demonstrates how to run a Minio container using Docker to serve on-premise files as an S3-compatible storage. It maps a local directory to the container's data volume and sets access keys. Ensure Docker is installed on your file server before running this command.

```bash
$ docker run -p 9000:9000 \
  -e "MINIO_ACCESS_KEY=AKIAIOSFODNN7EXAMPLE" \
  -e "MINIO_SECRET_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY" \
  -v /mnt/storage:/data \
  minio/minio server /data
```

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

### Example Group Policy for Wasabi Bucket Access (JSON)

Source: https://docs.wasabi.com/docs/creating-a-policy

This JSON policy grants a group of users permissions to list buckets, get bucket versioning, and access IAM resources related to their own user profile. It's designed to control group access to the Wasabi console and specific user information.

```json
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "AllowGroupToSeeBucketListInTheConsole", "Effect": "Allow",
"Action": [ "s3:ListAllMyBuckets", "s3:GetBucketVersioning" ],
"Resource": "arn:aws:s3:::*"
},
{
"Effect": "Allow", "Action": [
"iam:Get*",
"iam:List*", "iam:ChangePassword", "iam:UpdateLoginProfile", "iam:*MFA*",
"sts:Get*"
],
"Resource": "arn:aws:iam::${aws:accountid}:user/${aws:username}"
}
]
}
```

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

### Extract Cydex Installer Archive

Source: https://docs.wasabi.com/docs/how-do-i-use-cydex-with-wasabi

This command extracts the Cydex installer archive on a CentOS server. Ensure the installer file is present in the current directory before execution.

```bash
tar -xvzf 

```

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

### Download GeeseFS Binary

Source: https://docs.wasabi.com/docs/how-do-i-use-geesefs-with-wasabi

Downloads the latest GeeseFS Linux amd64 binary from GitHub releases and saves it to /usr/bin/geesefs for system-wide access.

```bash
wget https://github.com/yandex-cloud/geesefs/releases/latest/download/geesefs-linux-amd64 -O /usr/bin/geesefs
```

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

### Install Cydex Server in Archive Mode

Source: https://docs.wasabi.com/docs/how-do-i-use-cydex-with-wasabi

This command initiates the installation of the Cydex server with the archive function enabled on a CentOS system. You will be prompted to confirm the installation by entering 'y'.

```bash
sh install_archive.sh

```

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

### Copying ZebClient Configuration Files

Source: https://docs.wasabi.com/docs/how-do-i-use-zebclient-with-wasabi

Shell commands to copy the ZebClient configuration files to the /usr/local/etc/ directory on each cluster node. This step is crucial before launching the ZebClient Servers and Agents.

```bash
$ cp cluster-server1-1.conf /usr/local/etc/
$ cp cluster-server1-2.conf /usr/local/etc/
$ cp cluster-agent1.conf /usr/local/etc/
```

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

### Upload File using libcloud with Wasabi S3 Connector (Python)

Source: https://docs.wasabi.com/docs/how-do-i-use-libcloud-with-wasabi

This snippet demonstrates how to use Apache Libcloud's S3 connector to upload a file to Wasabi object storage. It requires Wasabi access and secret keys, and specifies the S3 host. The example shows setting up the driver, getting a container, and uploading an object via a stream, including optional metadata.

```python
from libcloud.storage.types import Provider
from libcloud.storage.providers import get_driver
from libcloud.storage.base import StorageDriver

FILE_PATH = '/Users/wasabi-test/qa/100kfile'

cls = get_driver(Provider.S3)
driver = cls('your_wasabi_access_key', 'your_wasabi_secret_key', host='s3.wasabisys.com')

container = driver.get_container(container_name='libcloud')

extra = {'meta_data': {'owner': 'myuser', 'created': '2014-02-2'}}

with open(FILE_PATH, 'rb') as iterator:
    obj = driver.upload_object_via_stream(iterator=iterator,
                                          container=container,
                                          object_name='backup.tar.gz',
                                          extra=extra)
```

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

### Configure ObjectiveFS with Wasabi

Source: https://docs.wasabi.com/docs/how-do-i-use-objectivefs-with-wasabi

This command initiates the configuration process for ObjectiveFS to connect with Wasabi. It prompts for your ObjectiveFS license, Wasabi access key ID, secret access key, and optionally the default region.

```bash
sudo mount.objectivefs config
```

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

### Perform Backup with Vertical Backup

Source: https://docs.wasabi.com/docs/how-do-i-use-vertical-backup-with-wasabi

This command initiates the backup process for specified virtual machines using the configured Vertical Backup and Wasabi storage. Ensure the storage has been previously initialized.

```bash
root@esxi55:/opt/vertical] ./vertical backup vm1 vm2
```

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

### Calculate Total Bucket Object Size with Python

Source: https://docs.wasabi.com/docs/how-to-get-total-size-of-current-non-current-objects-inside-a-bucket

This Python script, using the boto3 SDK, calculates the total size of current and non-current objects within a specified Wasabi bucket. It requires AWS SDK boto3 to be installed and can authenticate using configured AWS CLI profiles or direct API key entry. Ensure bucket versioning is turned off before execution for accurate size calculation.

```python
# Copyright (c) 2021. This script is available as fair use for users. This script can be used freely with Wasabi

import boto3
from botocore.exceptions import NoCredentialsError, PartialCredentialsError

def get_bucket_size(bucket_name, region):
    """Calculates the total size of current and non-current objects in a Wasabi bucket.

    Args:
        bucket_name (str): The name of the Wasabi bucket.
        region (str): The AWS region where the bucket is located.

    Returns:
        tuple: A tuple containing:
            - int: Total size of current objects in bytes.
            - int: Total size of non-current objects in bytes.
            - int: Combined total size of all objects in bytes.
        Returns (None, None, None) if an error occurs.
    """
    try:
        session = boto3.Session()
        s3_client = session.client('s3', region_name=region)

        total_current_size = 0
        total_non_current_size = 0

        # List current objects
        paginator_current = s3_client.get_paginator('list_objects_v2')
        for page in paginator_current.paginate(Bucket=bucket_name):
            if 'Contents' in page:
                for obj in page['Contents']:
                    total_current_size += obj['Size']

        # List non-current objects (requires versioning to be enabled on the bucket)
        # Note: The prompt mentions turning off versioning before running. 
        # If versioning is off, this part will not return non-current objects.
        # To get non-current objects, versioning must be ON.
        try:
            paginator_non_current = s3_client.get_paginator('list_object_versions')
            for page in paginator_non_current.paginate(Bucket=bucket_name):
                if 'Versions' in page:
                    for obj_version in page['Versions']:
                        # Exclude current versions if they are also listed here
                        # This logic assumes we want to sum up ALL versions, including current, 
                        # if versioning is enabled. If the goal is ONLY non-current, 
                        # additional filtering by 'IsLatest' would be needed.
                        total_non_current_size += obj_version['Size']
                if 'DeleteMarkers' in page: # Delete markers also count towards version history size
                    for delete_marker in page['DeleteMarkers']:
                        total_non_current_size += delete_marker['Size'] # Size is 0 for delete markers, but good practice to include
        except Exception as e:
            print(f"Could not list object versions (ensure versioning is enabled if needed): {e}")
            # If versioning is off as per instructions, this section is expected to fail or return nothing.
            # We proceed with current object size.
            total_non_current_size = 0

        total_combined_size = total_current_size + total_non_current_size

        return total_current_size, total_non_current_size, total_combined_size

    except (NoCredentialsError, PartialCredentialsError):
        print("AWS credentials not found. Please configure your credentials or use profiles.")
        return None, None, None
    except Exception as e:
        print(f"An error occurred: {e}")
        return None, None, None

if __name__ == "__main__":
    profile_name = input("Enter your AWS profile name (e.g., 'profilename') or leave blank to use default: ")
    bucket_name = input("Enter your Wasabi Bucket Name: ")
    region = input("Enter the region of your bucket (e.g., 'us-east-1'): ")

    session_args = {'region_name': region}
    if profile_name:
        session_args['profile_name'] = profile_name

    try:
        # Attempt to create a session with provided profile or default
        session = boto3.Session(**session_args)
        s3_client = session.client('s3') # Test client creation to catch profile errors early

        current_size, non_current_size, combined_size = get_bucket_size(bucket_name, region)

        if current_size is not None:
            print("\n--- Bucket Size Information ---")
            print(f"Bucket Name: {bucket_name}")
            print(f"Region: {region}")
            print(f"Total size of current objects: {current_size} bytes")
            print(f"Total size of non-current objects: {non_current_size} bytes")
            print(f"Combined total size (current + non-current): {combined_size} bytes")

    except Exception as e:
        print(f"Error setting up AWS session or executing script: {e}")
        print("Please ensure your AWS CLI profile is correctly configured or API keys are valid.")

```

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

### Manage OpenSearch Snapshots with Wasabi

Source: https://docs.wasabi.com/docs/how-do-i-use-opensearch-with-wasabi

These commands demonstrate how to create and monitor snapshots of your OpenSearch data stored in Wasabi. You can initiate a snapshot, wait for its completion, and check the status of ongoing snapshot operations.

```shell
curl -XPUT "http://localhost:9200/_snapshot/<repository-name>/1"

```

```shell
curl -XPUT "http://localhost:9200/_snapshot/<repository-name>/1?wait_for_completion=true"

```

```shell
curl -XGET "http://localhost:9200/_snapshot/_status"

```

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

### Creating a User Using IAM

Source: https://docs.wasabi.com/docs/how-do-i-use-aws-sdk-for-php-with-wasabi

Illustrates how to create a new IAM user with the specified username using the AWS SDK for PHP v3 and Wasabi's IAM endpoint.

```APIDOC
## Creating a User Using IAM

### Description
This example demonstrates how to create an IAM user with a specific username using the `IamClient` from the AWS SDK for PHP v3. It includes error handling for the creation process.

### Method
PHP

### Endpoint
`POST /` (Implicitly handled by the SDK when calling `createUser`)

### Parameters

#### Request Body
- **UserName** (string) - Required - The desired username for the new IAM user.

#### Client Configuration (within the script)
- **region** (string) - Required - The AWS region to use.
- **version** (string) - Required - The API version.
- **credentials** (object) - Required - An object containing `key` and `secret` for authentication.
  - **key** (string) - Required - Your IAM user's access key.
  - **secret** (string) - Required - Your IAM user's secret key.

### Request Example
```php
<?php

// Include the AWS SDK autoload.php file

require 'vendor/autoload.php';

// Import necessary classes from the AWS SDK
use Aws\Iam\IamClient;
use Aws\Exception\AwsException;

// AWS region, access key, and secret key
$region = 'your-aws-region'; // Replace with your AWS region
$accessKey = 'your-access-key'; // Replace with your IAM user's access key
$secretKey = 'your-secret-key'; // Replace with your IAM user's secret key

// Create an IAM client with specified configuration
$iamClient = new IamClient([ 'region' => $region, 'version' => 'latest', 'credentials' => [
'key' => $accessKey, 'secret' => $secretKey,
],
]);

// Desired IAM username to be created
$iamUserName = 'your-iam-username'; // Replace with the desired IAM username

try {
// Attempt to create an IAM user with the specified username
$result = $iamClient->createUser([ 'UserName' => $iamUserName,
]);

// If successful, display a message
echo "IAM user created: $iamUserName\n";
} catch (AwsException $exception) {
// If an error occurs, display an error message and exit
echo "Failed to create IAM user $iamUserName with error: " . $exception->getMessage() . "\n";
exit("Please fix error with IAM user creation before continuing.\n");

}
?>
```

### Response

#### Success Response (200)
- **User** (object) - Information about the created IAM user.
  - **Arn** (string) - The Amazon Resource Name (ARN) of the user.
  - **UserId** (string) - The unique ID of the user.
  - **CreateDate** (datetime) - The date and time when the user was created.
  - **UserName** (string) - The name of the user.

#### Response Example
```json
{
    "User": {
        "Arn": "arn:aws:iam::123456789012:user/your-iam-username",
        "UserId": "ABCDEFGHIJKLMN12345",
        "CreateDate": "2023-10-27T10:00:00Z",
        "UserName": "your-iam-username"
    },
    "ResponseMetadata": {
        "RequestId": "example-request-id"
    }
}
```

#### Error Response
- **Error** (object) - Contains details about the error.
  - **Code** (string) - The error code.
  - **Message** (string) - A description of the error.
```
Tokens:
Raw