Fleets on AWS

Streamtime creates and runs a Kubernetes cluster (Amazon EKS) in your AWS account, then installs what the fleet’s workloads need. You register the account once, then create fleets on it.

Key Features

  • Managed Kubernetes: Streamtime creates, monitors and deletes the EKS cluster for you.
  • Your network or a new one: use an existing VPC, or let Streamtime create one across two to four availability zones.
  • Tenancy: Shared, Isolated or Dedicated. See Tenancy.
  • Sized from your workloads: node types and counts follow the capacity you choose for each workload.
  • Monitoring: metrics, logs and alerts for the fleet and everything on it.

Prerequisites

  • AWS credentials (an access key ID and secret access key, plus a session token for temporary credentials) for an IAM user or role that can:
    • create EKS clusters (eks:CreateCluster) and IAM roles (iam:CreateRole);
    • create a VPC (ec2:CreateVpc), or read your existing one (ec2:DescribeVpcs);
    • create S3 buckets (s3:CreateBucket) for the fleet’s logs;
    • simulate its own policy (iam:SimulatePrincipalPolicy), so Streamtime can check these permissions before it creates anything.

    Streamtime refuses to create the fleet, and names what’s missing, when a permission is absent.

  • A Base Domain for the fleet’s endpoints, added under Settings.

Fleet settings

Placement Configuration

  • Account: the cloud account you registered.
  • Region: us-east-1 or us-west-2.

Advanced Configuration

  • VPC ID: an existing VPC, or leave it empty to create a new one.
  • VPC CIDR: the address range of a new VPC (10.0.0.0/16, 10.3.0.0/16, the default, or 172.16.0.0/16).
  • Availability Zones: 2 to 4 (default 3).
  • Public Cluster: whether the Kubernetes API is reachable from the internet (on by default).
  • VPC Tags: extra tags for the VPC and subnets Streamtime creates.
  • Logs Storage Bucket Name: optional; Streamtime generates a unique name when it’s empty.
  • Instance Type: optional; by default node types follow the fleet’s sizing.

Before you start

  • A Base Domain for the fleet’s endpoints, added under Settings.
  • For the API: an access token in STREAMTIME_TOKEN and your organization identifier in place of <org>. Replace api.example.com with your Streamtime API address.
  • Only administrators and infrastructure administrators can manage fleets and cloud accounts.

The API examples below share this setup:

export STREAMTIME_TOKEN=<your-access-token>
export API=https://api.example.com/organizations/<org>

import os
from streamtime_sdk.client import AuthenticatedClient

client = AuthenticatedClient(
    base_url="https://api.example.com",
    token=os.environ["STREAMTIME_TOKEN"],
)
ORG = "<org>"

Uses the generated client in streamtime-sdk/typescript/client.

import { client } from "./client/client.gen";

client.setConfig({
  baseUrl: "https://api.example.com",
  headers: { Authorization: `Bearer ${process.env.STREAMTIME_TOKEN}` },
});
const org = "<org>";

package main

import (
    "bytes"
    "crypto/rand"
    "encoding/hex"
    "encoding/json"
    "net/http"
    "os"
)

const api = "https://api.example.com/organizations/<org>"

// newKey returns a random idempotency key.
func newKey() string {
    b := make([]byte, 16)
    rand.Read(b)
    return hex.EncodeToString(b)
}

// call sends one request with the access token and a JSON body (or none).
// An optional idempotency key is sent as the Idempotency-Key header.
func call(method, path string, body any, idempotencyKey ...string) (*http.Response, error) {
    var buf bytes.Buffer
    if body != nil {
        if err := json.NewEncoder(&buf).Encode(body); err != nil {
            return nil, err
        }
    }
    req, err := http.NewRequest(method, api+path, &buf)
    if err != nil {
        return nil, err
    }
    req.Header.Set("Authorization", "Bearer "+os.Getenv("STREAMTIME_TOKEN"))
    req.Header.Set("Content-Type", "application/json")
    if len(idempotencyKey) > 0 {
        req.Header.Set("Idempotency-Key", idempotencyKey[0])
    }
    return http.DefaultClient.Do(req)
}

Register the cloud account

A cloud account holds the credentials Streamtime uses to create resources in your AWS account. Register it once; every fleet on that account uses it.

  1. Go to Settings, then Bootstrap Providers, and select + Add Bootstrap Provider.

  2. Basic Information: enter an Identifier for the account (lowercase letters, digits and dashes, up to 24 characters).

  3. Bootstrap Provider Details: choose AWS and fill in its credentials (see Prerequisites), then save.

The account appears in the list. Some clouds, such as AWS, are checked as you save: Streamtime refuses credentials the cloud rejects and says why. Streamtime checks the permissions again when you create a fleet.

curl -X POST "$API/bootstrap-providers/" \
  -H "Authorization: Bearer $STREAMTIME_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "identifier": "<cloud-account>",
    "provider": "aws",
    "configuration": {"aws_access_key": "<access-key-id>", "aws_access_secret": "<secret-access-key>"}
  }'

Returns 201 with the account. For some clouds, such as AWS, Streamtime checks the credentials with the cloud first and returns 400 with the cloud’s reason when they are rejected.

from streamtime_sdk.api.bootstrap_providers import organizations_bootstrap_providers_create
from streamtime_sdk.models import OrganizationsBootstrapProvidersCreateBody

account = organizations_bootstrap_providers_create.sync(
    ORG,
    client=client,
    body=OrganizationsBootstrapProvidersCreateBody.from_dict({
        "identifier": "<cloud-account>",
        "provider": "aws",
        "configuration": {"aws_access_key": "<access-key-id>", "aws_access_secret": "<secret-access-key>"},
    }),
)
print(account.identifier)

import { organizationsBootstrapProvidersCreate } from "./client";

const { data } = await organizationsBootstrapProvidersCreate({
  path: { org_identifier: org },
  body: {
    identifier: "<cloud-account>",
    provider: "aws",
    configuration: {"aws_access_key": "<access-key-id>", "aws_access_secret": "<secret-access-key>"},
  },
});
console.log(data?.identifier);

resp, err := call("POST", "/bootstrap-providers/", json.RawMessage(`{
    "identifier": "<cloud-account>",
    "provider": "aws",
    "configuration": {"aws_access_key": "<access-key-id>", "aws_access_secret": "<secret-access-key>"}
}`))
// resp.StatusCode is 201 on success.

streamtime provider create \
  --identifier <cloud-account> \
  --type aws \
  --config '{"aws_access_key": "<access-key-id>", "aws_access_secret": "<secret-access-key>"}'

List your accounts with streamtime provider list -O json.

Not available in MCP yet. Register the account from the UI, API or CLI.

resource "streamtime_cloud_account" "aws" {
  identifier     = "<cloud-account>"
  cloud_provider = "aws"

  configuration = jsonencode({"aws_access_key": "<access-key-id>", "aws_access_secret": "<secret-access-key>"})
}

Fill the credentials from sensitive variables or your secrets store, not from values written in the file. Terraform doesn’t read credentials back, so a change made outside Terraform isn’t detected. To manage an account that already exists, import it by identifier: terraform import streamtime_cloud_account.aws <cloud-account>, then set configuration and apply. See streamtime_cloud_account.

To change the credentials later, select Edit Credentials on the account in the UI, send PATCH $API/bootstrap-providers/<cloud-account>/ with a new configuration, or change configuration in Terraform and apply. Changing them from the CLI isn’t available yet.

Networks

A network is the VPC a fleet runs in. You don’t need one to create a fleet: without it, the fleet creates its own (see Fleet settings). Create a network when you want to manage it separately from any fleet. Leave out Existing Network ID and Streamtime creates the network in your cloud account; give the ID of one you already have and Streamtime only records it.

Create a network

  1. In the sidebar, select Network, then Create network.
  2. In Create Network, choose the Bootstrap Provider (your cloud account), enter an Identifier (lowercase letters, digits and dashes, up to 24 characters), a Name, the Region and, optionally, the CIDR.
  3. To use a network you already have, enter its ID in Existing Network ID instead of leaving it empty.
  4. Select Create.

The network appears in the list. A new one is empty until Streamtime has created it in the cloud; refresh the list to see its ID.

curl -X POST "$API/networks/" \
  -H "Authorization: Bearer $STREAMTIME_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"identifier": "prod-vpc", "provider": "<cloud-account>", "name": "prod-vpc", "region": "us-east-1", "cidr": "10.20.0.0/16"}'

Returns 201 with the network. identifier, provider (the cloud account) and name are required. Without network_id, Streamtime starts creating the network in the cloud and fills network_id in when it’s done: poll GET $API/networks/<network>/ until network_id has a value. With network_id, nothing is created.

The typed Network model marks server-set fields as required, so send the body with the SDK’s HTTP client:

resp = client.get_httpx_client().post(
    f"/organizations/{ORG}/networks/",
    json={"identifier": "prod-vpc", "provider": "<cloud-account>", "name": "prod-vpc", "region": "us-east-1", "cidr": "10.20.0.0/16"},
)
resp.raise_for_status()
print(resp.json()["identifier"])  # poll until "network_id" is set

The generated Network type doesn’t list every field the request takes, so send the body through the client directly:

const { data } = await client.post({
  url: "/organizations/{org_identifier}/networks/",
  path: { org_identifier: org },
  body: {"identifier": "prod-vpc", "provider": "<cloud-account>", "name": "prod-vpc", "region": "us-east-1", "cidr": "10.20.0.0/16"},
});
console.log((data as { identifier: string }).identifier); // poll until network_id is set

resp, err := call("POST", "/networks/", json.RawMessage(`{"identifier": "prod-vpc", "provider": "<cloud-account>", "name": "prod-vpc", "region": "us-east-1", "cidr": "10.20.0.0/16"}`))
// resp.StatusCode is 201; poll call("GET", "/networks/<network>/", nil)
// until "network_id" has a value.

streamtime network create --config '{"identifier": "prod-vpc", "provider": "<cloud-account>", "name": "prod-vpc", "region": "us-east-1", "cidr": "10.20.0.0/16"}'

List networks with streamtime network list -O json, and show one with streamtime network get <network>.

Not available in MCP yet. Create the network from the UI, API or CLI.

# Streamtime creates the VPC in the cloud account and fills in network_id.
resource "streamtime_network" "prod_vpc" {
  identifier    = "prod-vpc"
  name          = "prod-vpc"
  cloud_account = streamtime_cloud_account.aws.identifier
  region        = "us-east-1"
  cidr          = "10.20.0.0/16"
}

# Or record a VPC you already have: set network_id and nothing is created.
resource "streamtime_network" "existing" {
  identifier    = "shared-vpc"
  name          = "shared-vpc"
  cloud_account = streamtime_cloud_account.aws.identifier
  network_id    = "vpc-0123456789abcdef0"
}

To manage a network that already exists in Streamtime, import it by identifier: terraform import streamtime_network.prod_vpc prod-vpc. See streamtime_network.

Delete a network

Deleting a network removes it from Streamtime only. The VPC stays in your cloud account, and so do the resources in it. Remove them in the cloud console or CLI if you no longer need them.

  1. In the sidebar, select Network.
  2. Select the delete icon on the network’s row and confirm.
curl -X DELETE "$API/networks/<network>/" \
  -H "Authorization: Bearer $STREAMTIME_TOKEN"

Returns 204.

from streamtime_sdk.api.networks import organizations_networks_destroy

resp = organizations_networks_destroy.sync_detailed(ORG, "<network>", client=client)
print(resp.status_code)  # 204

import { organizationsNetworksDestroy } from "./client";

await organizationsNetworksDestroy({
  path: { org_identifier: org, identifier: "<network>" },
});

resp, err := call("DELETE", "/networks/<network>/", nil)
// resp.StatusCode is 204.

streamtime network delete <network> --yes

Not available in MCP yet. Delete the network from the UI, API or CLI.

Remove the streamtime_network block and run terraform apply, or run terraform destroy -target=streamtime_network.<name>. As above, this removes the record from Streamtime and leaves the cloud network in place.

Create a fleet

  1. In the sidebar, select Fleet, then + Add Fleet.

  2. Bootstrap Provider: choose AWS, then select Next.

    Bootstrap Provider step with the providers to choose from

  3. Basic Configuration: enter an Identifier, choose the Tenancy (Shared, Isolated or Dedicated), the Base Domain and Max Tenants (how many clusters the fleet can host). Under Workloads, choose what the fleet runs (Streaming, Stream Processing, Analytics) and how much capacity each gets; only the services those workloads need are installed. Optionally turn on Enable autoscale for workload node pool and Enable AI, and pick accounts under How should this fleet be monitored?

    Basic Configuration step with identifier, tenancy, domain and workloads

  4. Placement Configuration: choose the cloud account and where the fleet runs (see Fleet settings).

    Placement Configuration step with account and region

  5. Advanced Configuration: review the network and node settings.

    Advanced Configuration step with network and node settings

  6. Review the cost estimate on the right and select Deploy.

The fleet appears in the list as Pending, then Provisioning, then Healthy. Creating the Kubernetes cluster can take 20 minutes or more.

If you leave the wizard early, the fleet is kept as a draft (Incomplete). Open it from the list to pick up where you left off.

Creating a fleet takes two requests. The first saves the fleet; the second starts provisioning it.

# 1. Save the fleet. The response includes "generation" and "configuration_state".
curl -X POST "$API/fleet/" \
  -H "Authorization: Bearer $STREAMTIME_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "identifier": "payments-east",
    "provider": "aws",
    "domain": "<base-domain>",
    "tenancy_mode": "Shared",
    "placement_config": {"account": "<cloud-account>", "region": "us-east-1"},
    "advanced_config": {"aws_vpc_cidr": "10.3.0.0/16", "aws_az_count": 3}
  }'

# 2. Start provisioning that generation.
curl -X POST "$API/fleet/payments-east/reconcile/" \
  -H "Authorization: Bearer $STREAMTIME_TOKEN" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"generation": 1}'

identifier, provider and domain are required. Provisioning can start only once configuration_state is valid: the placement and advanced settings are complete. List the settings and their allowed values with GET $API/fleet/configuration-profiles/aws/placement-configuration/ and POST $API/fleet/configuration-profiles/aws/advanced-configuration/.

Add workloads to choose what the fleet runs, for example {"streaming": {"enabled": true, "providers": ["strimzi"], "units": 6}}. Without it, every workload is enabled.

The second request returns 202 with the operation it started. Retrying with the same Idempotency-Key returns that operation again. A 409 means the generation is out of date (send the generation from GET $API/fleet/payments-east/) or the configuration is incomplete.

Poll until status is Healthy (or Error):

curl -s "$API/fleet/payments-east/" -H "Authorization: Bearer $STREAMTIME_TOKEN"

The typed FleetCreate model can’t be used for this request yet, so save the fleet with the SDK’s HTTP client, then start provisioning:

import uuid

from streamtime_sdk.api.fleet import (
    organizations_fleet_reconcile_create,
    organizations_fleet_retrieve,
)
from streamtime_sdk.models import ReconcileRequest

resp = client.get_httpx_client().post(
    f"/organizations/{ORG}/fleet/",
    json={
        "identifier": "payments-east",
        "provider": "aws",
        "domain": "<base-domain>",
        "tenancy_mode": "Shared",
        "placement_config": {"account": "<cloud-account>", "region": "us-east-1"},
        "advanced_config": {"aws_vpc_cidr": "10.3.0.0/16", "aws_az_count": 3},
    },
)
resp.raise_for_status()
saved = resp.json()

if saved["configuration_state"] == "valid":
    organizations_fleet_reconcile_create.sync(
        ORG,
        "payments-east",
        client=client,
        body=ReconcileRequest(generation=saved["generation"]),
        idempotency_key=str(uuid.uuid4()),
    )

fleet = organizations_fleet_retrieve.sync(ORG, "payments-east", client=client)
print(fleet.status)  # Pending → Provisioning → Healthy

The generated FleetCreate type marks server-set fields as required, so send the body through the client directly, then start provisioning:

import {
  organizationsFleetReconcileCreate,
  organizationsFleetRetrieve,
} from "./client";

const { data: saved } = await client.post({
  url: "/organizations/{org_identifier}/fleet/",
  path: { org_identifier: org },
  body: {
    identifier: "payments-east",
    provider: "aws",
    domain: "<base-domain>",
    tenancy_mode: "Shared",
    placement_config: {"account": "<cloud-account>", "region": "us-east-1"},
    advanced_config: {"aws_vpc_cidr": "10.3.0.0/16", "aws_az_count": 3},
  },
});

await organizationsFleetReconcileCreate({
  path: { org_identifier: org, identifier: "payments-east" },
  headers: { "Idempotency-Key": crypto.randomUUID() },
  body: { generation: (saved as { generation: number }).generation },
});

const { data } = await organizationsFleetRetrieve({
  path: { org_identifier: org, identifier: "payments-east" },
});
console.log(data?.status);

resp, err := call("POST", "/fleet/", json.RawMessage(`{
    "identifier": "payments-east",
    "provider": "aws",
    "domain": "<base-domain>",
    "tenancy_mode": "Shared",
    "placement_config": {"account": "<cloud-account>", "region": "us-east-1"},
    "advanced_config": {"aws_vpc_cidr": "10.3.0.0/16", "aws_az_count": 3}
}`))
if err != nil {
    return err
}
defer resp.Body.Close()

var saved struct {
    Generation         int    `json:"generation"`
    ConfigurationState string `json:"configuration_state"`
}
if err := json.NewDecoder(resp.Body).Decode(&saved); err != nil {
    return err
}

// Start provisioning that generation.
resp, err = call("POST", "/fleet/payments-east/reconcile/",
    map[string]any{"generation": saved.Generation}, newKey())
// Then poll: call("GET", "/fleet/payments-east/", nil) until "status" is "Healthy".

streamtime fleet create \
  --identifier payments-east \
  --provider aws \
  --domain <base-domain> \
  --tenancy-mode Shared \
  --streaming strimzi --streaming-units 6 \
  --placement-config '{"account": "<cloud-account>", "region": "us-east-1"}' \
  --advanced-config '{"aws_vpc_cidr": "10.3.0.0/16", "aws_az_count": 3}'

When the settings are complete, the command also starts provisioning. If they aren’t, it saves the fleet and says what’s missing; finish the settings, then run streamtime fleet reconcile payments-east.

Choose workloads with --streaming, --stream-processing and --analytics (each takes a comma-separated list of providers) and their --…-units options. Without them, every workload is enabled.

Not available in MCP yet. Create the fleet from the UI, API or CLI.

resource "streamtime_fleet" "payments_east" {
  identifier     = "payments-east"
  fleet_provider = "aws"
  domain         = "<base-domain>"
  tenancy_mode   = "Shared"

  placement_config = jsonencode({"account": "<cloud-account>", "region": "us-east-1"})
  advanced_config  = jsonencode({"aws_vpc_cidr": "10.3.0.0/16", "aws_az_count": 3})

  # The placement refers to the account by name, so tell Terraform to
  # create the account first.
  depends_on = [streamtime_cloud_account.aws]

  timeouts = {
    create = "90m"
    delete = "60m"
  }
}

terraform apply saves the fleet, starts provisioning it, and waits until it is ready, so allow for the AWS cluster taking 20 minutes or more (the timeouts block). Read the placement_config and advanced_config fields AWS accepts, and their allowed values, from the streamtime_fleet_configuration_profile data source. They match the API’s fleet settings.

Changes to placement_config or advanced_config on a running fleet are saved but not applied yet (see Update the fleet or the Agent). To manage a fleet that already exists, import it by identifier: terraform import streamtime_fleet.payments_east payments-east. See streamtime_fleet.

Check fleet status

A fleet’s Status is one of Incomplete, Pending, Provisioning, Updating, Restarting, Deleting, Healthy or Error. The Agent’s connection and the installed components show whether Streamtime can reach the fleet and what it runs.

  1. In the sidebar, select Fleet. Each fleet’s status shows in the list.

    Fleet list showing each fleet's status

  2. Open the fleet. Overview shows its status, tenancy, Kafka Units and capacity. Endpoints lists its addresses, and Monitoring its metrics.

    Fleet overview with status, tenancy and capacity

  3. Agent Management shows whether the Agent is installed and connected, with the history of its operations.

# Status and provisioning state
curl -s "$API/fleet/payments-east/" -H "Authorization: Bearer $STREAMTIME_TOKEN"

# Collect a fresh health report from the fleet (waits for the answer)
curl -s -X POST "$API/fleet/payments-east/status/" -H "Authorization: Bearer $STREAMTIME_TOKEN"

# The Agent's connection
curl -s "$API/fleet/payments-east/agent/" -H "Authorization: Bearer $STREAMTIME_TOKEN"

# Installed components
curl -s "$API/fleet/payments-east/installed-components/" -H "Authorization: Bearer $STREAMTIME_TOKEN"

In the fleet, status is the fleet’s state and reconciliation_state the state of its last operation (queued, running, succeeded or failed). GET $API/fleet/payments-east/status/ returns the last health report without collecting a new one. The Agent’s status reads bootstrap_complete once it is installed and the fleet is set up.

from streamtime_sdk.api.agent import get_agent_connection
from streamtime_sdk.api.fleet import organizations_fleet_retrieve
from streamtime_sdk.api.fleet_metrics import organizations_fleet_status_create

fleet = organizations_fleet_retrieve.sync(ORG, "payments-east", client=client)
print(fleet.status, fleet.reconciliation_state)

report = organizations_fleet_status_create.sync_detailed(ORG, "payments-east", client=client)
print(report.content.decode())

agent = get_agent_connection.sync_detailed(ORG, "payments-east", client=client)
print(agent.content.decode())

import {
  getAgentConnection,
  organizationsFleetRetrieve,
  organizationsFleetStatusCreate,
} from "./client";

const { data: fleet } = await organizationsFleetRetrieve({
  path: { org_identifier: org, identifier: "payments-east" },
});
console.log(fleet?.status, fleet?.reconciliation_state);

const report = await organizationsFleetStatusCreate({
  path: { org_identifier: org, fleet_id: "payments-east" },
});
const agent = await getAgentConnection({
  path: { org_identifier: org, fleet_id: "payments-east" },
});
console.log(report.data, agent.data);

resp, err := call("GET", "/fleet/payments-east/", nil)
// Decode "status" and "reconciliation_state" from resp.Body.

resp, err = call("POST", "/fleet/payments-east/status/", nil)  // fresh health report
resp, err = call("GET", "/fleet/payments-east/agent/", nil)    // Agent connection

streamtime fleet list
streamtime fleet get payments-east
streamtime fleet status payments-east
streamtime fleet kubeconfig payments-east --save ./payments-east.kubeconfig

fleet status shows the last health report. Showing the Agent’s connection or the installed components isn’t available in the CLI yet.

Ask your assistant, for example: “Is the payments-east fleet healthy?” or “What alerts fired on payments-east in the last hour?”

It uses get_fleet_status (pass refresh to collect a fresh report), list_fleet_resources, get_fleet_alerts, get_fleet_logs and get_fleet_metric.

Update the fleet or the Agent

You can turn the workload node pool’s autoscaling on or off, and change the accounts that receive the fleet’s monitoring data. Streamtime can’t apply changes to a fleet’s placement or advanced settings yet: they are saved, but the update operation fails. To change them, create a new fleet.

The Agent is the Streamtime component that runs inside the fleet. Update it to a new version from Agent Management.

  1. Open the fleet and select Agent Management.
  2. Open the actions menu (⋮) and select Update Agent.
  3. In Update Streamtime Agent, choose the Target (Worker or Operator) and the Registry, then set the Image Tag (leave it empty for the latest), or the Chart Version or Helm Values you want to change. Start the update.

The operation shows under Command History until it finishes.

# Turn autoscaling of the workload node pool off
curl -X PATCH "$API/fleet/payments-east/" \
  -H "Authorization: Bearer $STREAMTIME_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"autoscale": false}'

# Update the Agent to a new version
curl -X POST "$API/fleet/payments-east/agent/UpdateStreamtimeAgentWorkflow/" \
  -H "Authorization: Bearer $STREAMTIME_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "update_types": ["agent"],
    "registry_url": "<registry>",
    "repository": "<repository>",
    "agent": {"image_tag": "<version>"}
  }'

registry_url and repository are where your Streamtime installation publishes the Agent image; ask your Streamtime administrator. The update returns 201 with the operation it started. Follow it with GET $API/fleet/payments-east/agent/.

from streamtime_sdk.api.fleet import organizations_fleet_partial_update
from streamtime_sdk.api.fleet_tasks import dispatch_agent_task
from streamtime_sdk.models import DispatchAgentTaskWorkflowType, PatchedFleet

organizations_fleet_partial_update.sync(
    ORG, "payments-east", client=client, body=PatchedFleet(autoscale=False)
)

resp = dispatch_agent_task.sync_detailed(
    ORG,
    "payments-east",
    DispatchAgentTaskWorkflowType.UPDATESTREAMTIMEAGENTWORKFLOW,
    client=client,
    body={
        "update_types": ["agent"],
        "registry_url": "<registry>",
        "repository": "<repository>",
        "agent": {"image_tag": "<version>"},
    },
)
print(resp.status_code)  # 201

import { dispatchAgentTask, organizationsFleetPartialUpdate } from "./client";

await organizationsFleetPartialUpdate({
  path: { org_identifier: org, identifier: "payments-east" },
  body: { autoscale: false },
});

await dispatchAgentTask({
  path: {
    org_identifier: org,
    fleet_id: "payments-east",
    workflow_type: "UpdateStreamtimeAgentWorkflow",
  },
  body: {
    update_types: ["agent"],
    registry_url: "<registry>",
    repository: "<repository>",
    agent: { image_tag: "<version>" },
  },
});

resp, err := call("PATCH", "/fleet/payments-east/", map[string]any{"autoscale": false})

resp, err = call("POST", "/fleet/payments-east/agent/UpdateStreamtimeAgentWorkflow/", map[string]any{
    "update_types": []string{"agent"},
    "registry_url": "<registry>",
    "repository":   "<repository>",
    "agent":        map[string]any{"image_tag": "<version>"},
})
// resp.StatusCode is 201 once the update has started.

Not available in the CLI yet. Update the fleet or the Agent from the UI or the API.

Not available in MCP yet. Update the fleet or the Agent from the UI or the API.

Delete the fleet

Delete every cluster and workload on the fleet first; Streamtime refuses to delete a fleet that still hosts one. Deleting the fleet removes the resources Streamtime created for it.

  1. In the sidebar, select Fleet.
  2. Open the fleet’s menu in the list, select Delete, and confirm.

The fleet shows Deleting, then disappears from the list.

curl -X DELETE "$API/fleet/payments-east/" -H "Authorization: Bearer $STREAMTIME_TOKEN"

Returns 202 with the delete operation it started. 403 means the fleet still hosts Kafka clusters; 409 means it still has Kafka Connect clusters, replicators or virtual Kafka clusters. Delete those first. Poll GET $API/fleet/payments-east/: it shows Deleting, then returns 404 once the fleet is gone.

from streamtime_sdk.api.fleet import organizations_fleet_destroy

resp = organizations_fleet_destroy.sync_detailed(ORG, "payments-east", client=client)
print(resp.status_code)  # 202; 403 or 409 while workloads remain

import { organizationsFleetDestroy } from "./client";

await organizationsFleetDestroy({
  path: { org_identifier: org, identifier: "payments-east" },
});

resp, err := call("DELETE", "/fleet/payments-east/", nil)
// resp.StatusCode is 202 (403 or 409 while workloads remain);
// poll GET /fleet/payments-east/ until it returns 404.

streamtime fleet delete payments-east --yes

Not available in MCP yet. Delete the fleet from the UI, API or CLI.

terraform destroy -target=streamtime_fleet.payments_east

Or remove the streamtime_fleet block and run terraform apply. Terraform starts the delete and waits until the fleet is gone (the delete timeout). Streamtime refuses the delete while the fleet still hosts workloads, so remove those first.

Remove the cloud account

Delete every fleet on the account first, and wait until they are gone. Streamtime doesn’t stop you from removing an account that fleets still use, and without it those fleets can’t be torn down.

  1. Go to Settings, then Bootstrap Providers.
  2. Select Delete on the account and confirm.
curl -X DELETE "$API/bootstrap-providers/<cloud-account>/" \
  -H "Authorization: Bearer $STREAMTIME_TOKEN"

Returns 204.

from streamtime_sdk.api.bootstrap_providers import organizations_bootstrap_providers_destroy

resp = organizations_bootstrap_providers_destroy.sync_detailed(
    ORG, "<cloud-account>", client=client
)
print(resp.status_code)  # 204

import { organizationsBootstrapProvidersDestroy } from "./client";

await organizationsBootstrapProvidersDestroy({
  path: { org_identifier: org, identifier: "<cloud-account>" },
});

resp, err := call("DELETE", "/bootstrap-providers/<cloud-account>/", nil)
// resp.StatusCode is 204.

streamtime provider delete <cloud-account> --yes

Not available in MCP yet. Remove the account from the UI, API or CLI.

# Preview what will be removed, then remove it.
terraform plan -destroy -target=streamtime_cloud_account.aws
terraform destroy -target=streamtime_cloud_account.aws

Terraform deletes the fleets that depend on the account first when they are in the same configuration, so check that the plan lists them. It only follows dependencies it can see: fleets managed in another configuration or outside Terraform aren’t checked, so delete them first, as above.