Spheron Compute SDK

npm i @spheron/compute

yarn add @spheron/compute

import SpheronClient from "@spheron/compute";
 
const client = new SpheronClient({ token });

const organization: Organization = await spheron.organization.get();

interface Organization {
  id: string;
  profile: {
    name: string,
    username: string,
    image: string,
  };
}

const clusters: Cluster[] = await spheron.organization.getClusters({
  skip: 0,
  limit: 10
});

const usage: UsageWithLimits = await spheron.organization.getUsage();

interface UsageWithLimits {
  used: {
    computeCredit: number; // the amount used by organization, in usd
    computeBuildExecution: number; // the time used for builds, in seconds
    numberOfRequests: number; // the number of requests organization has had until now
    bandwidth: number; // the bytes of bandwith used for current subscription
    domains: number; // the number of domains and subdomains an organization has
  };
  limit: {
    computeCredit: number; // the amount limit for organization, in usd
    computeBuildExecution: number; // the time limit for builds, in seconds
    bandwidth: number; // the limit of bandwith for subscription
    domains: number; // the limit on how many domains and subdomains can an organization have
  };
}

const cluster: Cluster = await spheron.cluster.get(clusterId);

interface Cluster {
  id: string; // id of a cluster
  name: string; // name of a cluster
  url: string; // docker image
  proivder: ProviderEnum; // docker image provider (currently only dockerhub is supported)
  createdBy: string; // id of the user that created cluster
  createdAt: Date; 
  updatedAt: Date;
};
 
enum ProviderEnum {
    DOCKERHUB
};
 

await spheron.cluster.delete(clusterId);

const instanceInfo: InstancesInfo = await spheron.cluster.getInstancesInfo(clusterId);

interface InstancesInfo {
    provisioned: number; // number of provisioned instances in cluster
    provisioning: number; // number of provisioning instances in cluster
    failedToProvision: number; // number of fail to provision instances in cluster
    closed: number; // number of closed instances in cluster
    total: number; // total number of instances in cluster
}

const clusterUsage: ClusterFundsUsage = await spheron.cluster.getUsage(clusterId);

interface ClusterFundsUsage {
    dailyUsage: number; // cluster daily usage in usd
    usedTillNow: number; // cluster daily usage in usd
}

const instances: InstanceDetailed[] =
  await spheron.cluster.getInstances(
    clusterId,
    options: {
      skip: 0,
      limit: 10
    }
  );

interface InstanceDetailed {
  id: string; // id of a istance
  state: InstanceStateEnum; // state of a instance
  name: string; // name of a instance
  deployments: Array<string>; // list of all instance deployment ids
  cluster: string; // instance cluster id
  activeDeployment: string; // id of active deployment
  agreedMachine: MachineImageType; // compute machine information
  healthCheck: HealthCheck; // instance health check endpoint information
  cpu: number; // compute machine cpu
  memory: string; // compute machine memory
  storage: string; // compute machine storage
  image: string; // docker image
  tag: string; // docker tag
  createdAt: Date;
  updatedAt: Date;
}

const instanceResponse: InstanceResponse =
  await spheron.instance.create(creationConfig: {
  clusterName: "hello world",
  configuration: {
    image: "crccheck/hello-world",
    tag: "latest",
    ports: [{ containerPort: 8000, exposedPort: 8000 }],
    environmentVariables: [],
    secretEnvironmentVariables: [],
    commands: [],
    args: [],
    region: "any",
    machineImageId: ventusSmallId
  },
  healthCheckConfig: {
    path: "/",
    port: 8000
  }
});

interface InstanceResponse {
  clusterId: string; // id of cluster instance is deployed in
  instanceId: string;  // id of instance
  instanceDeploymentId: string;  // id of instance deployment
}

const instance: Instance = await spheron.instance.get(instanceId);

interface Instance {
  id: string; // id of a istance
  state: InstanceStateEnum; // state of a instance
  name: string; // name of a instance
  deployments: Array<string>; // list of all instance deployment ids
  cluster: string; // instance cluster id
  activeDeployment: string; // id of active deployment
  agreedMachine: MachineImageType; // compute machine information
  healthCheck: HealthCheck; // instance health check endpoint information
  createdAt: Date;
  updatedAt: Date;
};
 
interface MachineImageType {
    machineName: string; // compute machine type
    agreementDate: number; // date of deploying instance
}
 
enum InstanceStateEnum {
    STARTING,
    FAILED_START,
    ACTIVE,
    CLOSED
};
 
interface HealthCheck {
    path: string; // healthcheck path
    port: Port; // cotainer port on which healthcheck should be done
    status: HealthStatusEnum; // latest health check status
    timestamp: Date; // timestamp of last health check
};
 
enum HealthStatusEnum {
    ACTIVE,
    INACTIVE,
    UNKNOWN
}
 

await spheron.instance.delete(instanceId);

await spheron.instance.update(
  instanceId,
  {
    environmentVariables: [{ key: "key", value: "value"}],
    secretEnvironmentVariables: [{ key: "key", value: "value"}],
    commands: ["executable"],
    args: ["param"],
    tag: "latest";
  }
);

interface InstanceResponse {
  clusterId: string; // id of cluster instance is deployed in
  instanceId: string;  // id of instance
  instanceDeploymentId: string;  // id of instance deployment
}

const updated = await spheron.instance.updateHealthCheck(
  instanceId,
  { path: "/health", port: 3000 }
);

{ 
  message: string; // the response message
  success: boolean; // the flag signaling if action was successful
}

const closed = await spheron.instance.close(instanceId);

{ 
  message: string; // the response message
  success: boolean; // the flag signaling if action was successful
}

const deployment: InstanceDeployment; = await spheron.instance.getInstanceDeployment(deploymentId);

interface InstanceDeployment {
  id: string; // id of deployment
  type: DeploymentTypeEnum; // type of deployment
  status: DeploymentStatusEnum; // status of deployment
  buildTime: number; // deployment build time
  instance: string; // id of instance
  connectionUrls: string; // list of connection url for the deployed instance
  deploymentInitiator: string; // userId that initiated deployment
  instanceConfiguration: {
    image: string; // docker image
    tag: string; // docker image tag
    ports: Array<Port>; // port mappings
    environmentVariables: Array<EnvironmentVar>; // environment variables
    secretEnvironmentVariables: Array<EnvironmentVar>; // secret environment variables
    commands: Array<string>; // list of executables for docker CMD command 
    args: Array<string>; // list of params for docker CMD command 
    region: string; // region to which instance is deployed
    agreedMachineImage: MachineImageType
  };
};
 
// Note: This is used to determine the instance deployment type
enum DeploymentTypeEnum {
  DEPLOY,
  UPDATE,
}
 
enum DeploymentStatusEnum {
  QUEUED,
  PENDING,
  DEPLOYED,
  FAILED,
  DEPRECATED,
  DEPRECATED_PROVIDER,
};
 
interface Port {
    containerPort: number; // container port
    exposedPort: number; // eposed port container port is mapped to
};
 
interface EnvironmentVariable {
  key: string; // environment variable key 
  value: string; // environment variable value 
  isSecret: boolean; // is environment variable secret 
};
 
interface MachineImageType {
    machineName: string; // compute machine name
    agreementDate: number; // date of deploying instance
    cpu?: number; // compute machine cpu
    memory?: string; // compute machine memory
    storage?: string; // compute machine storage
    persistentStorage?: PersistentStorage; // persistent storege information
}
 
interface PersistentStorage {
    size: string;
    class: PersistentStorageClassEnum;
    mountPoint: string;
};
 
enum PersistentStorageClassEnum {
    BETA1,
    BETA2,
    BETA3
}

const instanceLogs: Array<string> = await spheron.instance.getInstanceLogs(
    deploymentId,
    {
      from: 0;
      to: 1000;
      logType: InstanceLogType.DEPLOYMENT_LOGS;
      search: searchString;
    });

  enum InstanceLogType {
    DEPLOYMENT_LOGS, // the logs of instance deployment process
    INSTANCE_LOGS, // the logs from container running on instance
    INSTANCE_EVENTS // the logs of instance events
}

const instanceCreate: MarketplaceInstanceResponse =
  await spheron.instance.createFromMarketplace(
    {
      marketplaceAppId: marketplaceAppId;
      environmentVariables: [
        {key: "User", value: "admin"},
        {key: "Password", value: "super secret password"},
        {key: "Database", value: "mydb" }
      ];
      machineImageId: machineId;
      region: "any";
    }
  );

interface MarketplaceInstanceResponse {
  marketplaceApp: MarketplaceApp; // marketplace app used 
  marketplaceAppId: string; // the id of the marketplace app
  clusterId: string; // the id of the cluster instance belongs to
  instanceId: string; // the id of the instance
  instanceDeploymentId: string; // the id of the instance deployment
}

const domains: Domain[] = await spheron.instance.getDomains(instanceId);

interface Domain {
  id: string; // the id of the domain
  name: string; // the domain name
  verified: boolean; // true means that the domain is verified and that it will start serving the content
  link: string; // the link to which the domain points to
  type: DomainTypeEnum; // the type of the domain
  instanceId: string; // the instance id of which the domain is
};
 
enum DomainTypeEnum {
    DOMAIN,
    SUBDOMAIN
}

const domain: Domain = await spheron.instance.addDomain(instanceId, {
  name: "domain.com",
  type: DomainTypeEnum.DOMAIN,
  link: connectionUrl
});

const domain: Domain = await spheron.instance.updateDomain(
  instanceId,
  domainId,
  {
    name: "test.com",
    type: DomainTypeEnum.DOMAIN,
    link: connectionUrl,
  }
);

const domain: Domain = await spheron.instance.verifyDomain(instanceId, domainId);

await spheron.instance.deleteDomain(instanceId, domainId);

await spheron.instance.triggerLatestLog(instanceId);

{
  message: string; // the response message
}

await spheron.instance.triggerLatestHealth(instanceId);

{
  message: string; // the response message
}

const marketplaceApps: MarketplaceApp[] =
  await spheron.computeMarketplace.getAll();

const marketplaceApp: MarketplaceApp =
  await spheron.computeMarketplace.get(marketplaceAppId);

interface MarketplaceApp {
  id: string; // id of a marketplace app
  name: string; // name of a marketplace app
  description: string; // description of a marketplace app
  category: MarketplaceCategoryEnum; // marketplace app category
  variables: MarketplaceAppVariable[]; // list of enironemt variables
};
 
enum MarketplaceCategoryEnum {
    DATABASE,
    NODE,
    TOOLS
};
 
interface MarketplaceAppVariable {
  defaultValue: string;
  key: string;
  required?: string;
}

const categories: string[] = await spheron.computeMarketplace.getCategories();

const computeMachines: ComputeMachine[] = await spheron.computeMachine.get({
  skip: 0,
  limit: 10,
  search: "2Gi"
});

interface ComputeMachine {
  id: string; // id of compute machine
  name: string; // name of compute machine
  cpu: number; // compute machine cpu
  storage: string; // compute machine storage
  memory: string; // compute machine memeory
}

const regions: string[] = await spheron.computeMachine.getRegions();