> ## Documentation Index
> Fetch the complete documentation index at: https://docs.tensor9.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Cloud Adapter Overview

> Keep your cloud APIs. Choose where your software runs.

**Tensor9 Cloud Adapter emulates your cloud inside another.** Keep using your existing cloud SDKs, CLI commands and Terraform providers while running your software in a different cloud or on-prem. Cloud Adapter translates the APIs your application already uses into calls to your chosen backend, then returns responses in the formats your tools expect.

![Your stack connects through Tensor9 Cloud Adapter to services in another cloud or private environment.](https://mintcdn.com/tensor9/ufP2gYsEkScmc1Bt/images/cloud-adapter-early-access/diagrams/cloud-adapter-light.png?fit=max\&auto=format\&n=ufP2gYsEkScmc1Bt\&q=85\&s=6e69d0b9e2905414ce48ac4fa0c1a77a)

![Your stack connects through Tensor9 Cloud Adapter to services in another cloud or private environment.](https://mintcdn.com/tensor9/ufP2gYsEkScmc1Bt/images/cloud-adapter-early-access/diagrams/cloud-adapter-light.png?fit=max\&auto=format\&n=ufP2gYsEkScmc1Bt\&q=85\&s=6e69d0b9e2905414ce48ac4fa0c1a77a)

![Your stack connects through Tensor9 Cloud Adapter to services in another cloud or private environment.](https://mintcdn.com/tensor9/ufP2gYsEkScmc1Bt/images/cloud-adapter-early-access/diagrams/cloud-adapter-dark.png?fit=max\&auto=format\&n=ufP2gYsEkScmc1Bt\&q=85\&s=f04c007c54993b5b0a68c70c5814dbe5)

![Your stack connects through Tensor9 Cloud Adapter to services in another cloud or private environment.](https://mintcdn.com/tensor9/ufP2gYsEkScmc1Bt/images/cloud-adapter-early-access/diagrams/cloud-adapter-dark.png?fit=max\&auto=format\&n=ufP2gYsEkScmc1Bt\&q=85\&s=f04c007c54993b5b0a68c70c5814dbe5)

## Who Cloud Adapter is for

Cloud Adapter is for software vendors and enterprises that want the freedom to choose their cloud while keeping the cloud integrations they already have.

* **Software vendors expanding into new marketplaces.** Reach customers in additional cloud marketplaces by running your product in those environments, while keeping its existing cloud integrations.
* **Software vendors reducing infrastructure costs.** Move your product to a lower-cost cloud or choose a more cost-effective backend for individual services, while retaining your existing SDKs, CLI commands and Terraform configurations.
* **Enterprises using multiple clouds to control costs.** Choose the cloud and backend that offer the best economics for each workload. Keep the APIs your applications already use across those environments, so each cloud choice does not require a separate application integration.
* **Vendors deploying into customer environments.** Offer the same product in a customer's chosen cloud or on-prem environment, including deployments driven by data-location requirements.

For example, your product can keep using the S3 API while storing objects in Google Cloud Storage, or the DynamoDB API while using Azure Cosmos DB. Your team works with the APIs it knows; Cloud Adapter handles the backend translation.

## How it works

1. **Choose what to emulate and where to run it.** Select the cloud APIs your software uses and the backend services that will provide them in the new environment.
2. **Point your existing tools at Cloud Adapter.** Configure the adapter endpoint in your SDK, CLI or Terraform provider, along with the application credentials.
3. **Run your software.** Cloud Adapter translates supported API calls to the selected backend and returns responses in the format your application expects.

Each mapping connects a familiar cloud API to a specific backend. The examples below use AWS APIs with services in Google Cloud and Azure.

### Request and response architecture

Your application sends familiar cloud API requests to Cloud Adapter. The adapter calls the chosen backend services and translates their responses back for your application.

![An AWS CLI or SDK sends S3 API calls to Cloud Adapter, which calls the GCS API and stores objects in Google Cloud Storage. A second path sends DynamoDB API calls to Cloud Adapter, which calls the Cosmos DB API and stores items in Azure Cosmos DB.](https://mintcdn.com/tensor9/ufP2gYsEkScmc1Bt/images/cloud-adapter-early-access/diagrams/cloud-adapter-origin-api-light.svg?fit=max\&auto=format\&n=ufP2gYsEkScmc1Bt\&q=85\&s=9d8722d1b0db23320d7f73c253441f61)

Support is directional and specific to each origin service, backend and operation. One service adapter provides one origin-to-target service mapping; a cloud adapter groups those mappings for a cloud direction. Check the [S3-to-Cloud Storage profile](https://docs.tensor9.com/cloud-adapter-early-access/service-catalog/aws/databases-storage/s3.md#on-google-cloud) or [DynamoDB-to-Cosmos DB profile](https://docs.tensor9.com/cloud-adapter-early-access/service-catalog/aws/databases-storage/dynamodb-table.md#on-azure) for the behavior your workload needs.

## Use a standard SDK

Use the standard, unmodified SDK for the cloud your software was built for. Configure the adapter endpoint using the SDK's normal endpoint option; request signing and response parsing continue to use that cloud's API.

For example, the standard AWS SDK for Python, boto3, can write the same object through the S3 API. Configure your region and origin-side credentials through the normal AWS credential chain before running this example. With the selected S3-to-Cloud Storage profile and bucket configured:

```python theme={null}
import os

import boto3
from botocore.config import Config

s3 = boto3.client(
    "s3",
    endpoint_url=os.environ["T9_CLOUD_ADAPTER_ENDPOINT"],
    config=Config(s3={"addressing_style": "path"}),
)

with open("./report.pdf", "rb") as body:
    s3.put_object(Bucket="media", Key="report.pdf", Body=body)
```

`endpoint_url` and path-style S3 addressing are standard SDK configuration. No SDK fork or custom request format is required for this example. The same operation and service-pair limitations apply to SDK and CLI requests.

## Examples with the AWS CLI

Before trying either example, the adapter must be running, its endpoint and origin-side credentials must be configured, and the named target resources must exist. Set `T9_CLOUD_ADAPTER_ENDPOINT` to your adapter endpoint. The commands below use illustrative resource names.

### Store an object in Google Cloud Storage using S3

With S3 mapped to Google Cloud Storage, send an S3 `PutObject` request:

```bash theme={null}
aws s3api put-object --bucket media --key report.pdf --body ./report.pdf \
  --endpoint-url "$T9_CLOUD_ADAPTER_ENDPOINT"
```

The object lands in the configured Cloud Storage bucket. The AWS CLI still sends an S3 request and receives an S3-shaped response, so the client keeps the same command and request format.

### Read an Azure Cosmos DB item using DynamoDB

For a DynamoDB table mapped to provisioned Azure Cosmos DB, send a supported `GetItem` request:

```bash theme={null}
aws dynamodb get-item --table-name orders \
  --key '{"customerId":{"S":"C-42"},"orderId":{"S":"O-1042"}}' \
  --endpoint-url "$T9_CLOUD_ADAPTER_ENDPOINT"
```

Cloud Adapter reads the mapped Cosmos DB item and returns DynamoDB-typed attributes. Configure the corresponding table and key names before using this example. Confirm the selected pair's supported request shape before relying on it in your workload.

## Use Terraform or OpenTofu

Terraform and OpenTofu use a cloud provider's normal API calls. Configure the provider to send supported service calls to Cloud Adapter, which translates them to your chosen backends. You keep the provider and its familiar resource definitions.

For an existing test bucket using S3 backed by Google Cloud Storage, the AWS provider's standard `endpoints` setting directs S3 calls to the adapter. This configuration fragment comes from the bounded S3 example for AWS provider `5.100.0`; `adapter_endpoint` is the endpoint of your running adapter:

```hcl theme={null}
provider "aws" {
  region = "us-east-1"

  endpoints {
    s3 = var.adapter_endpoint
  }

  s3_use_path_style = true

  # Keep provider startup on the configured S3 route. These switches avoid
  # metadata, region, credential-validation, and account-discovery calls.
  skip_credentials_validation = true
  skip_metadata_api_check     = true
  skip_region_validation      = true
  skip_requesting_account_id  = true
}
```

Supply origin-side credentials through the provider's normal credential chain. The four `skip_*` options keep that provider version's startup checks from contacting metadata, region validation or AWS STS outside the configured S3 route; they do not disable Cloud Adapter authentication. Reassess the provider's API calls before changing versions.

Start with an isolated workspace and an existing test bucket. Check the exact resource lifecycle you need, including create, read, refresh and delete, through both the origin API and the target service. Changing a provider endpoint is not application-data migration and can affect refresh or replacement plans. Verify behavior before redirecting a production workspace.

## Get started with Cloud Adapter

Install the Tensor9 CLI with Homebrew:

```bash theme={null}
brew tap tensor9ine/tensor9
brew trust tensor9ine/tensor9
brew install tensor9
tensor9 --version
```

The CLI bundles its own runtime. No separate Java installation is required. Homebrew 7 and later requires trusting the Tensor9 tap once per machine before installing or upgrading.

Installing the CLI is the first step. Running an adapter requires a Tensor9 customer account, access to the selected service pair, target-cloud resources and appropriately scoped identities. Your Tensor9 API key is for the Tensor9 CLI; it is separate from application and target-cloud credentials. [Install the CLI and configure `T9_API_KEY`](https://docs.tensor9.com/cloud-adapter-early-access/getting-started/install-and-authenticate) before using it to inspect, acquire or run an adapter.

Setup accepts a complete configuration file or guides you through questions to generate one. For a focused evaluation, begin with one service pair and disposable test resources using the existing foreground `tensor9 adapt svc run` workflow. Full deployments use `tensor9 adapt cloud install` to prepare the target-cloud fabric that hosts the serving image, with configuration, networking and credentials prepared for that environment.

The local container launcher is pending. The Homebrew commands above install the CLI; they do not deploy a running adapter or establish production readiness. Confirm supported operations and verify one bounded request before expanding the workload.

## Connect locally for development and testing

Keep your application, debugger and tests on your laptop while requests use your installed Cloud Adapter and its configured cloud backends. In one terminal, open a tunnel using the directory printed by `adapt cloud install`:

```bash theme={null}
tensor9 adapt cloud connect \
  --dir "$HOME/tensor9/dev-adapter" --forward
```

Leave that terminal running. In a second terminal, load the installation's AWS profile and local endpoint, then verify your identity:

```bash theme={null}
eval "$(tensor9 adapt cloud connect \
  --dir "$HOME/tensor9/dev-adapter" --env)"
aws sts get-caller-identity
```

Run your application or tests from that shell, using your SDK's normal endpoint settings. The local endpoint is `http://127.0.0.1:65534`; target resources and cloud billing remain in your development project or subscription. Ctrl-C stops the tunnel and leaves the installation running. See [Local development with a cloud installation](https://docs.tensor9.com/cloud-adapter-early-access/local-testing/local-development.md) for SDK examples, credentials and reconnecting.

## Choose your next step

> [card] [Plan your setup](https://docs.tensor9.com/cloud-adapter-early-access/getting-started/overview.md)
>
> Choose services and backends, then prepare configuration, identity and networking.

> [card] [Use an existing cloud tool](https://docs.tensor9.com/cloud-adapter-early-access/guides/index.md)
>
> Use the AWS CLI, SDKs, Terraform/OpenTofu, Pulumi and other API clients with the origin endpoint.

> [card] [Check service mappings](https://docs.tensor9.com/cloud-adapter-early-access/service-catalog/aws/catalog.md)
>
> Check supported operations and behavior for your chosen service and backend.

> [card] [Work with included agents](https://docs.tensor9.com/cloud-adapter-early-access/support/agents.md)
>
> Investigate a question and coordinate support or operational work. You can also connect your own agents.

> [card] [Tune your workload](https://docs.tensor9.com/cloud-adapter-early-access/tuning/overview.md)
>
> Understand tuning options and measure a change against your workload.

> [card] [Debug a request](https://docs.tensor9.com/cloud-adapter-early-access/debugging/overview.md)
>
> Follow request evidence from the origin API through the adapter to the target service.

Cloud Adapter includes agents for [Support](https://docs.tensor9.com/cloud-adapter-early-access/support/agents.md) and [Operations](https://docs.tensor9.com/cloud-adapter-early-access/operations/overview.md). They work from your selected Cloud Adapter, permitted evidence and tools.

Use [Explain](https://docs.tensor9.com/cloud-adapter-early-access/debugging/explain.md) and [worked investigations](https://docs.tensor9.com/cloud-adapter-early-access/debugging/worked-examples.md) to understand covered requests. Use [High Fidelity Cloud Emulators](https://docs.tensor9.com/cloud-adapter-early-access/local-testing/overview.md) to exercise supported behavior before testing against the real backend. For software delivery into another organization's infrastructure, see [Tensor9 BYOC](https://docs.tensor9.com/byoc/index.md).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.