Code Examples

import torch
import torch.nn as nn
import torch.optim as optim
from orbex import OrbexClient

# Initialize Orbex client
client = OrbexClient(api_key="your-api-key")

# Create GPU instance
instance = client.compute.create(
    name="pytorch-training",
    instance_type="gpu-a100",
    image="pytorch:latest-gpu"
)

# Define a simple neural network
class SimpleNet(nn.Module):
    def __init__(self):
        super(SimpleNet, self).__init__()
        self.fc1 = nn.Linear(784, 128)
        self.fc2 = nn.Linear(128, 10)
        
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# Initialize model and move to GPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = SimpleNet().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

print(f"Training on device: {device}")
print(f"Instance ID: {instance.id}")

from orbex import OrbexClient
import pandas as pd
import schedule
import time

client = OrbexClient(api_key="your-api-key")

def process_daily_data():
    # Download data from bucket
    data = client.storage.download("bucket://data-lake/daily/sales.csv")
    
    # Process data with pandas
    df = pd.read_csv(data)
    df['processed_date'] = pd.Timestamp.now()
    df['total_revenue'] = df['quantity'] * df['price']
    
    # Upload processed data
    processed_path = f"bucket://processed/sales_{pd.Timestamp.now().strftime('%Y%m%d')}.csv"
    client.storage.upload_dataframe(df, processed_path)
    
    # Load into database
    client.database.load_data(
        source=processed_path,
        table="analytics.daily_sales",
        mode="append"
    )
    
    print(f"Processed {len(df)} records at {pd.Timestamp.now()}")

# Schedule daily processing
schedule.every().day.at("02:00").do(process_daily_data)

# Run scheduler
while True:
    schedule.run_pending()
    time.sleep(60)

package main

import (
    "fmt"
    "log"
    "sync"
    "github.com/orbex/orbex-go"
)

func main() {
    client := orbex.NewClient("your-api-key")
    
    // Define source and target buckets
    sourceBucket := "primary-data-us-east"
    targetBuckets := []string{
        "backup-data-us-west",
        "backup-data-eu-west",
        "backup-data-ap-south",
    }
    
    // List objects in source bucket
    objects, err := client.Storage.ListObjects(sourceBucket)
    if err != nil {
        log.Fatal(err)
    }
    
    // Sync to all target buckets concurrently
    var wg sync.WaitGroup
    
    for _, targetBucket := range targetBuckets {
        wg.Add(1)
        go func(target string) {
            defer wg.Done()
            syncBucket(client, sourceBucket, target, objects)
        }(targetBucket)
    }
    
    wg.Wait()
    fmt.Println("Sync completed for all regions")
}

func syncBucket(client *orbex.Client, source, target string, objects []orbex.Object) {
    for _, obj := range objects {
        err := client.Storage.CopyObject(
            source, obj.Key,
            target, obj.Key,
        )
        if err != nil {
            log.Printf("Failed to sync %s to %s: %v", obj.Key, target, err)
            continue
        }
        fmt.Printf("Synced %s to %s\n", obj.Key, target)
    }
}

const { OrbexClient } = require('@orbex/sdk');

const client = new OrbexClient({
  apiKey: process.env.ORBEX_API_KEY
});

// Deploy serverless function
async function deployAPI() {
  const deployment = await client.compute.createServerless({
    name: 'user-api',
    runtime: 'nodejs18',
    handler: 'index.handler',
    code: `
      exports.handler = async (event) => {
        const { method, path, body } = event;
        
        switch (path) {
          case '/users':
            if (method === 'GET') {
              return {
                statusCode: 200,
                body: JSON.stringify({ users: await getUsers() })
              };
            }
            break;
          case '/users':
            if (method === 'POST') {
              const user = await createUser(JSON.parse(body));
              return {
                statusCode: 201,
                body: JSON.stringify(user)
              };
            }
            break;
          default:
            return {
              statusCode: 404,
              body: JSON.stringify({ error: 'Not found' })
            };
        }
      };
      
      async function getUsers() {
        // Database query logic
        return [{ id: 1, name: 'John Doe' }];
      }
      
      async function createUser(userData) {
        // User creation logic
        return { id: Date.now(), ...userData };
      }
    `,
    environment: {
      NODE_ENV: 'production'
    },
    scaling: {
      minInstances: 0,
      maxInstances: 100,
      targetConcurrency: 10
    }
  });
  
  console.log(`API deployed: ${deployment.url}`);
  return deployment;
}

deployAPI().catch(console.error);

from orbex import OrbexClient
import torch
import torchvision.transforms as transforms
from PIL import Image
import io
import base64

client = OrbexClient(api_key="your-api-key")

# Load pre-trained model
model = torch.load('bucket://models/resnet50_trained.pth')
model.eval()

# Define image preprocessing
transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], 
                        std=[0.229, 0.224, 0.225])
])

def predict_image(image_data):
    # Decode base64 image
    image = Image.open(io.BytesIO(base64.b64decode(image_data)))
    
    # Preprocess image
    input_tensor = transform(image).unsqueeze(0)
    
    # Make prediction
    with torch.no_grad():
        outputs = model(input_tensor)
        probabilities = torch.nn.functional.softmax(outputs[0], dim=0)
        
    # Get top 5 predictions
    top5_prob, top5_catid = torch.topk(probabilities, 5)
    
    results = []
    for i in range(top5_prob.size(0)):
        results.append({
            'class_id': top5_catid[i].item(),
            'probability': top5_prob[i].item(),
            'confidence': f"{top5_prob[i].item() * 100:.2f}%"
        })
    
    return results

# Deploy inference endpoint
endpoint = client.ml.deploy_endpoint(
    name="image-classifier",
    handler=predict_image,
    instance_type="gpu-t4",
    auto_scaling={
        'min_instances': 1,
        'max_instances': 10,
        'target_latency_ms': 100
    }
)

print(f"Inference endpoint deployed: {endpoint.url}")

# main.tf
terraform {
  required_providers {
    orbex = {
      source  = "orbex/orbex"
      version = "~> 1.0"
    }
  }
}

provider "orbex" {
  api_key = var.orbex_api_key
  region  = var.region
}

# Create VPC
resource "orbex_vpc" "main" {
  name       = "ml-training-vpc"
  cidr_block = "10.0.0.0/16"
  
  tags = {
    Environment = var.environment
    Project     = "ml-training"
  }
}

# Create subnet
resource "orbex_subnet" "private" {
  name               = "ml-training-private"
  vpc_id            = orbex_vpc.main.id
  cidr_block        = "10.0.1.0/24"
  availability_zone = "us-east-1a"
}

# Create security group
resource "orbex_security_group" "ml_training" {
  name   = "ml-training-sg"
  vpc_id = orbex_vpc.main.id

  ingress {
    from_port   = 22
    to_port     = 22
    protocol    = "tcp"
    cidr_blocks = ["10.0.0.0/16"]
  }

  ingress {
    from_port   = 8888
    to_port     = 8888
    protocol    = "tcp"
    cidr_blocks = ["10.0.0.0/16"]
  }

  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}

# Create GPU instances for ML training
resource "orbex_compute_instance" "ml_workers" {
  count = var.worker_count

  name          = "ml-worker-${count.index + 1}"
  instance_type = "gpu-a100"
  image         = "pytorch:latest-gpu"
  subnet_id     = orbex_subnet.private.id
  
  security_group_ids = [orbex_security_group.ml_training.id]
  
  user_data = base64encode(templatefile("user_data.sh", {
    worker_id = count.index + 1
  }))

  tags = {
    Environment = var.environment
    Role        = "ml-worker"
    WorkerID    = count.index + 1
  }
}

# Create storage bucket for training data
resource "orbex_storage_bucket" "training_data" {
  name   = "ml-training-data-${random_id.bucket_suffix.hex}"
  region = var.region
  
  lifecycle_configuration {
    rule {
      id     = "training_data_lifecycle"
      status = "Enabled"
      
      transition {
        days          = 30
        storage_class = "COLD"
      }
      
      expiration {
        days = 365
      }
    }
  }
}

resource "random_id" "bucket_suffix" {
  byte_length = 4
}

# Output important values
output "vpc_id" {
  value = orbex_vpc.main.id
}

output "ml_worker_ips" {
  value = orbex_compute_instance.ml_workers[*].private_ip
}

output "training_bucket" {
  value = orbex_storage_bucket.training_data.name
}