NEO GPU (Pulumi)

NEO GPU rents NVIDIA H200 instances (/neo-gpus API group), billed by subscription cycle or on-demand (hourly). Exactly one billing mode must be set - validation fails otherwise.

Every create places a real paid order. On-demand instances accumulate hourly charges until deleted.

`biznetgio:index:GpuInstance`

import * as biznetgio from "@shirasakaren/biznetgio";

const products = biznetgio.gpuProductsOutput();

const keypair = new biznetgio.GpuKeypair("gpu-key", {
  name: "gpu-key",
});

const gpu = new biznetgio.GpuInstance("gpu-1", {
  productId: products.products[0].productId,
  selectOs: "ubuntu-22",
  keypairId: keypair.id.apply((id) => Number(id)),
  serviceName: "neo-gpu-1",
  sshAndConsoleUser: "root",
  consolePassword: "s3cretP4ssw0rd",
  payWithCreditCard: true,
  subscription: { cycle: "m" },
  // one-shot actions (change value to fire):
  // rebuildTrigger: "rebuild-1",
  // reserveAdditionalHoursTrigger: "reserve-1",
});

import pulumi
import pulumi_biznetgio

products = pulumi_biznetgio.gpu_products()

keypair = pulumi_biznetgio.GpuKeypair(
    "gpu-key",
    name="gpu-key",
)

gpu = pulumi_biznetgio.GpuInstance(
    "gpu-1",
    product_id=products.products[0].product_id,
    select_os="ubuntu-22",
    keypair_id=pulumi.Output.from_input(keypair.id).apply(int),
    service_name="neo-gpu-1",
    ssh_and_console_user="root",
    console_password="s3cretP4ssw0rd",
    pay_with_credit_card=True,
    subscription=pulumi_biznetgio.GpuInstanceSubscriptionArgs(cycle="m"),
    # rebuild_trigger="rebuild-1",
    # reserve_additional_hours_trigger="reserve-1",
)

package main

import (
    biznetgio "github.com/shirasakaren/pulumi-biznetgio/sdk/go/pulumi-biznetgio"
    "github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
    pulumi.Run(func(ctx *pulumi.Context) error {
        products, err := biznetgio.GpuProducts(ctx, &biznetgio.GpuProductsArgs{})
        if err != nil {
            return err
        }

        keypair, err := biznetgio.NewGpuKeypair(ctx, "gpu-key", &biznetgio.GpuKeypairArgs{
            Name: pulumi.String("gpu-key"),
        })
        if err != nil {
            return err
        }

        gpu, err := biznetgio.NewGpuInstance(ctx, "gpu-1", &biznetgio.GpuInstanceArgs{
            ProductId:         pulumi.Int(products.Products[0].ProductId),
            SelectOs:          pulumi.String("ubuntu-22"),
            KeypairId:         keypair.ID().ToIntOutput(),
            ServiceName:       pulumi.String("neo-gpu-1"),
            SshAndConsoleUser: pulumi.String("root"),
            ConsolePassword:   pulumi.String("s3cretP4ssw0rd"),
            PayWithCreditCard: pulumi.Bool(true),
            Subscription: &biznetgio.GpuInstanceSubscriptionArgs{
                Cycle: pulumi.String("m"),
            },
            // RebuildTrigger:                  pulumi.String("rebuild-1"),
            // ReserveAdditionalHoursTrigger:   pulumi.String("reserve-1"),
        })
        if err != nil {
            return err
        }

        ctx.Export("gpuStatus", gpu.Status)
        return nil
    })
}

using System;
using System.Collections.Generic;
using Pulumi;
using Shirasakaren.Biznetgio;

return await Deployment.RunAsync(() =>
{
    var products = GpuProducts.Invoke();

    var keypair = new GpuKeypair("gpu-key", new GpuKeypairArgs
    {
        Name = "gpu-key",
    });

    var gpu = new GpuInstance("gpu-1", new GpuInstanceArgs
    {
        ProductId = products.Apply(p => p.Products[0].ProductId),
        SelectOs = "ubuntu-22",
        KeypairId = keypair.Id.Apply(v => int.Parse(v)),
        ServiceName = "neo-gpu-1",
        SshAndConsoleUser = "root",
        ConsolePassword = "s3cretP4ssw0rd",
        PayWithCreditCard = true,
        Subscription = new GpuInstanceSubscriptionArgs { Cycle = "m" },
        // RebuildTrigger = "rebuild-1",
        // ReserveAdditionalHoursTrigger = "reserve-1",
    });

    return new Dictionary<string, object?>
    {
        ["gpuStatus"] = gpu.Status,
    };
});

package demo;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import ren.shirasaka.biznetgio.*;
import ren.shirasaka.biznetgio.inputs.GpuSubscriptionArgs;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    private static void stack(Context ctx) {
        var products = BiznetgioFunctions.gpuProducts();

        var keypair = new GpuKeypair("gpu-key",
            GpuKeypairArgs.builder()
                .name("gpu-key")
                .build());

        var gpu = new GpuInstance("gpu-1",
            GpuInstanceArgs.builder()
                .productId(products.applyValue(p -> p.products().get(0).productId()))
                .selectOs("ubuntu-22")
                .keypairId(keypair.id().applyValue(Integer::parseInt))
                .serviceName("neo-gpu-1")
                .sshAndConsoleUser("root")
                .consolePassword("s3cretP4ssw0rd")
                .payWithCreditCard(true)
                .subscription(GpuSubscriptionArgs.builder().cycle("m").build())
                // .rebuildTrigger("rebuild-1")
                // .reserveAdditionalHoursTrigger("reserve-1")
                .build());

        ctx.export("gpuStatus", gpu.status());
    }
}

resources:
  gpu:
    type: biznetgio:index:GpuInstance
    properties:
      productId: ${products[0].productId}
      selectOs: ubuntu-22
      keypairId: ${fn::toNumber(keypair.id)}
      serviceName: neo-gpu-1
      sshAndConsoleUser: root
      consolePassword: s3cretP4ssw0rd
      payWithCreditCard: true
      subscription:
        cycle: m

Hourly billing instead of subscription:

onDemand: { additionalHours: 0 },

on_demand=pulumi_biznetgio.GpuInstanceOnDemandArgs(additional_hours=0),

OnDemand: &biznetgio.GpuInstanceOnDemandArgs{
    AdditionalHours: pulumi.Int(0),
},

OnDemand = new GpuInstanceOnDemandArgs { AdditionalHours = 0 },

.onDemand(GpuOnDemandArgs.builder().additionalHours(0).build())

onDemand:
  additionalHours: 0

Input	Type	Required	Notes
`productId`	int64	yes	from `gpuProducts`; create-only
`selectOs`	string	yes	from the product’s select-OS catalog; create-only
`keypairId`	int64	yes	from `GpuKeypair`; create-only
`sshAndConsoleUser`	string	yes	create-only
`consolePassword`	string, secret	yes	create-only
`serviceName`	string	no	create-only
`promocode`	string	no	create-only
`payWithCreditCard`	bool	no	default `true`; create-only
`subscription`	object	one-of	`{ cycle: "m" \| "a" }`; create-only
`onDemand`	object	one-of	`{ additionalHours?: number }` default 0; create-only
`rebuildTrigger`	string	no	one-shot destructive OS reinstall
`reserveAdditionalHoursTrigger`	string	no	one-shot: reserves additional hour(s)

keypairId comes from GpuKeypair’s id converted to a number, as in the examples above - GpuKeypair exposes no separate keypairId output, unlike the other keypair resources. Outputs: status, orderId, raw (secret, redacted). Import with the numeric account id.

Every input above except the two triggers is create-only in Pulumi - a change destroys and recreates the instance. The Terraform provider’s equivalent resource does not handle this safely: changing product_id, select_os, or keypair_id there causes a permanent, unresolvable plan diff instead of a replace - see the Terraform reference if you also use Terraform for NEO GPU.

`biznetgio:index:GpuKeypair`

const keypair = new biznetgio.GpuKeypair("gpu-key", {
  name: "gpu-key",
});
export const privateKey = keypair.privateKey;

keypair = pulumi_biznetgio.GpuKeypair(
    "gpu-key",
    name="gpu-key",
)
pulumi.export("privateKey", keypair.private_key)

keypair, err := biznetgio.NewGpuKeypair(ctx, "gpu-key", &biznetgio.GpuKeypairArgs{
    Name: pulumi.String("gpu-key"),
})
ctx.Export("privateKey", keypair.PrivateKey)

var keypair = new GpuKeypair("gpu-key", new GpuKeypairArgs
{
    Name = "gpu-key",
});
// keypair.PrivateKey

var keypair = new GpuKeypair("gpu-key",
    GpuKeypairArgs.builder()
        .name("gpu-key")
        .build());
ctx.export("privateKey", keypair.privateKey());

keypair:
  type: biznetgio:index:GpuKeypair
  properties:
    name: gpu-key

Input name; outputs publicKey, privateKey (secret - returned only at creation), raw (secret). No update.

Functions

For real pricing and how to pick a specific package instead of trusting [0], see the Product Catalog page.

`biznetgio:index:gpuProducts`

No arguments. Returns products: productId, name, description, categoryName, flavors (flavorId, name, raw), raw (secret).

`biznetgio:index:gpuConsole`

Argument accountId (string). Returns url (secret) and raw (secret). Side-effecting: each call mints a new one-time console session - do not use it inside plan diffing.

`biznetgio:index:gpuGraph`

Arguments accountId (string), timeframe (optional, default hour; hour / day / week / month / year). Returns graph and raw (secret) from GET /neo-gpus/accounts/{id}/graph-monitor.

Getting Started

Tutorials

Terraform Provider

Pulumi Provider

Guides

About

`biznetgio:index:GpuInstance`

`biznetgio:index:GpuKeypair`

Functions

`biznetgio:index:gpuProducts`

`biznetgio:index:gpuConsole`

`biznetgio:index:gpuGraph`

​biznetgio:index:GpuInstance

​biznetgio:index:GpuKeypair

​Functions

​biznetgio:index:gpuProducts

​biznetgio:index:gpuConsole

​biznetgio:index:gpuGraph

`biznetgio:index:GpuInstance`

`biznetgio:index:GpuKeypair`

Functions

`biznetgio:index:gpuProducts`

`biznetgio:index:gpuConsole`

`biznetgio:index:gpuGraph`