SDKs

pip install vxsdk            # canonical name
pip install vxsdk[async]    # adds httpx for the async flavor
 
# Brand-alias package — same code, just `import vxcloud`:
pip install vxcloud
pip install vxcloud[async]

import vxsdk
# Or equivalently: `import vxcloud` (alias package — same code).
 
# Auth: load credentials written by `vxcli auth login`
c = vxsdk.Client.load_from_vxcli()
# Equivalent aliases — all resolve to the same Client class:
#   c = vxsdk.VxCloud.load_from_vxcli()
#   c = vxsdk.vxcloud.load_from_vxcli()
# Or explicit:
#   c = vxsdk.Client(api_key="xc_live_…", username="alice")
 
# Provision a VM — `c.cloud.vm.provision(...)` mirrors the TypeScript SDK.
# The legacy flat `c.cloud.create_vm(...)` also still works.
vm = c.cloud.vm.provision(name="api-vm", cloud="aws", region="us-east-1",
                          instance_type="t3.small", key_pair_name="AWSPRODKEY2")
 
# Deploy a Docker container WITH HTTPS — single call.
# Installs host nginx + Let's Encrypt cert in front of the first port (3000).
# Requires grafana.example.com A record -> vm["public_ip"] already set.
ssh = dict(host=vm["public_ip"], ssh_user="ubuntu",
           key_pair_name="AWSPRODKEY1")    # keypair must be in Vault
sess = c.deploy.container(
    image="grafana/grafana:latest",
    name="grafana",
    ports=["3000:3000"],
    enable_ssl=True,
    domain="grafana.example.com",
    ssl_email="[email protected]",
    **ssh,
)
print(sess["session_id"], sess.get("ssl_certificate_status"))
 
# Manage it
print(c.services.list(**ssh))
print(c.services.status("grafana", **ssh))
c.services.restart("grafana", **ssh)
 

npm install @vxcloud/sdk
# or:  pnpm add @vxcloud/sdk
# or:  yarn add @vxcloud/sdk
 
# All four named exports below alias the SAME class — pick whichever
# import name your team prefers:
#   import { VxCloud } from '@vxcloud/sdk';     // canonical (PascalCase)
#   import { vxcloud } from '@vxcloud/sdk';     // lowercase brand
#   import { Vxsdk }   from '@vxcloud/sdk';     // mirrors Python `vxsdk`
#   import { Client }  from '@vxcloud/sdk';     // mirrors `vxsdk.Client`

import { VxCloud } from '@vxcloud/sdk';
// Equivalent imports (all alias the same class):
//   import { vxcloud, Vxsdk, Client } from '@vxcloud/sdk';
 
// Auth: load credentials written by `vxcli auth login`
const c = await VxCloud.loadFromVxcli();
// or:  new VxCloud({ apiKey: 'xc_live_…', username: 'alice' });
 
// Provision a VM
const vm = await c.cloud.vm.provision({
  cloud: 'aws', instanceType: 't3.small', region: 'us-east-1',
  keyPairName: 'AWSPRODKEY2',
});
 
// Deploy a Docker container WITH HTTPS — single call.
// Installs host nginx + Let's Encrypt cert in front of the first port (3000).
// Requires grafana.example.com A record -> vm.public_ip already set.
const ssh = {
  host: vm.public_ip as string,
  sshUser: 'ubuntu',
  keyPairName: 'AWSPRODKEY1',          // must be in Vault
};
const sess = await c.deploy.container({
  image: 'grafana/grafana:latest', name: 'grafana',
  ports: ['3000:3000'],
  enableSsl: true,
  domain:    'grafana.example.com',
  sslEmail:  '[email protected]',
  ...ssh,
});
console.log(sess.sessionId, sess.sslCertificateStatus);
 
// Manage it
console.log(await c.services.list(ssh));
await c.services.restart('grafana', ssh);
 

go get github.com/prodxcloud/vxcloud@latest

package main
 
import (
    "context"
    "fmt"
    vxsdk "github.com/prodxcloud/vxcloud"
)
 
import (
    "github.com/prodxcloud/vxcloud/deploy"
    "github.com/prodxcloud/vxcloud/install"
)
 
func main() {
    ctx := context.Background()
    c, err := vxsdk.LoadFromVxcli(ctx) // or vxsdk.New(ctx, vxsdk.WithAPIKey(...))
    if err != nil { panic(err) }
 
    pipelines, _ := c.CICD().Pipelines().List(ctx)
    for _, p := range pipelines {
        fmt.Println(p.ID, p.Name)
    }
 
    // Single-call HTTPS deploy: container + nginx + Let's Encrypt cert.
    // Requires grafana.example.com A record -> 13.216.243.13 already set.
    sess, _ := c.Deploy().Container(ctx, deploy.ContainerOpts{
        SSH: install.SSH{
            Host: "13.216.243.13", User: "ubuntu",
            KeyPairName: "AWSPRODKEY1",     // must be in Vault
        },
        Name:      "grafana",
        Image:     "grafana/grafana:latest",
        Ports:     []string{"3000:3000"},
        EnableSSL: true,
        Domain:    "grafana.example.com",
        SSLEmail:  "[email protected]",
    })
    fmt.Println(sess.SessionID, sess.AccessURL)
}

terraform {
  required_providers {
    VxCloud = {
      source  = "VxCloud/VxCloud"
      version = "~> 1.0"
    }
  }
}

provider "VxCloud" {
  api_key   = var.VxCloud_api_key
  workspace = var.workspace_id
}
 
resource "VxCloud_aws_credentials" "main" {
  access_key_id     = var.aws_access_key_id
  secret_access_key = var.aws_secret_access_key
  region            = "us-east-1"
}
 
resource "VxCloud_vm" "api" {
  provider      = "aws"
  instance_type = "t3.small"
  region        = "us-east-1"
  key_pair_name = "AWSPRODKEY2"
  tags = { app = "studio-backend" }
  depends_on    = [VxCloud_aws_credentials.main]
}
 
output "api_ip" { value = VxCloud_vm.api.public_ip }