Quickstart (Pulumi)

From zero to a running NEO Lite VM in about five minutes, in any supported language.

Prerequisites

Pulumi CLI installed
A Biznet GIO account
An API token - see Authentication

Get started

Create a project

mkdir biznetgio-demo && cd biznetgio-demo
pulumi new typescript

npm install @shirasakaren/biznetgio

pip install pulumi-biznetgio

go get github.com/shirasakaren/pulumi-biznetgio/sdk/go/pulumi-biznetgio

dotnet add package Shirasakaren.Biznetgio

# build.gradle
# implementation("ren.shirasaka:biznetgio:0.1.7")

Set your API token

pulumi config set --secret biznetgio:apiToken <your-token>

Alternatively export BIZNETGIO_API_KEY.

Write the program

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

const products = biznetgio.neoliteProductsOutput();
const osList = biznetgio.neoliteOsListOutput({
  productId: products.products[0].productId,
});

const keypair = new biznetgio.NeoliteKeypair("demo-keypair", {
  name: "neo-lite-key",
});

const vm = new biznetgio.NeoliteVm("demo-vm", {
  vmName: "neo-lite-1",
  productId: products.products[0].productId,
  selectOs: osList.oss[0].name,
  keypairId: keypair.keypairId,
  cycle: "m",
  sshAndConsoleUser: "adminuser",
  consolePassword: "s3cretP4ssw0rd",
});

export const vmStatus = vm.status;

import pulumi
import pulumi_biznetgio

products = pulumi_biznetgio.neolite_products()
os_list = pulumi_biznetgio.neolite_os_list_output(
    product_id=products.products[0].product_id,
)

keypair = pulumi_biznetgio.NeoliteKeypair(
    "demo-keypair",
    name="neo-lite-key",
)

vm = pulumi_biznetgio.NeoliteVm(
    "demo-vm",
    vm_name="neo-lite-1",
    product_id=products.products[0].product_id,
    select_os=os_list.oss[0].name,
    keypair_id=keypair.keypair_id,
    cycle="m",
    ssh_and_console_user="adminuser",
    console_password="s3cretP4ssw0rd",
)

pulumi.export("vmStatus", vm.status)

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.NeoliteProducts(ctx, &biznetgio.NeoliteProductsArgs{})
        if err != nil {
            return err
        }
        osList, err := biznetgio.NeoliteOsList(ctx, &biznetgio.NeoliteOsListArgs{
            ProductId: products.Products[0].ProductId,
        })
        if err != nil {
            return err
        }

        keypair, err := biznetgio.NewNeoliteKeypair(ctx, "demo-keypair", &biznetgio.NeoliteKeypairArgs{
            Name: pulumi.String("neo-lite-key"),
        })
        if err != nil {
            return err
        }

        vm, err := biznetgio.NewNeoliteVm(ctx, "demo-vm", &biznetgio.NeoliteVmArgs{
            VmName:            pulumi.String("neo-lite-1"),
            ProductId:         pulumi.Int(products.Products[0].ProductId),
            SelectOs:          pulumi.String(osList.Oss[0].Name),
            KeypairId:         keypair.KeypairId,
            Cycle:             pulumi.String("m"),
            SshAndConsoleUser: pulumi.String("adminuser"),
            ConsolePassword:   pulumi.String("s3cretP4ssw0rd"),
        })
        if err != nil {
            return err
        }

        ctx.Export("vmStatus", vm.Status)
        return nil
    })
}

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

return await Deployment.RunAsync(() =>
{
    var products = NeoliteProducts.Invoke();
    var osList = NeoliteOsList.Invoke(new NeoliteOsListInvokeArgs
    {
        ProductId = products.Apply(p => p.Products[0].ProductId),
    });

    var keypair = new NeoliteKeypair("demo-keypair", new NeoliteKeypairArgs
    {
        Name = "neo-lite-key",
    });

    var vm = new NeoliteVm("demo-vm", new NeoliteVmArgs
    {
        VmName = "neo-lite-1",
        ProductId = products.Apply(p => p.Products[0].ProductId),
        SelectOs = osList.Apply(o => o.Oss[0].Name),
        KeypairId = keypair.KeypairId,
        Cycle = "m",
        SshAndConsoleUser = "adminuser",
        ConsolePassword = "s3cretP4ssw0rd",
    });

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

package demo;

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

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

    private static void stack(Context ctx) {
        var products = BiznetgioFunctions.neoliteProducts();
        var osList = BiznetgioFunctions.neoliteOsList(
            NeoliteOsListArgs.builder()
                .productId(products.applyValue(p -> p.products().get(0).productId()))
                .build());

        var keypair = new NeoliteKeypair("demo-keypair",
            NeoliteKeypairArgs.builder()
                .name("neo-lite-key")
                .build());

        var vm = new NeoliteVm("demo-vm",
            NeoliteVmArgs.builder()
                .vmName("neo-lite-1")
                .productId(products.applyValue(p -> p.products().get(0).productId()))
                .selectOs(osList.applyValue(o -> o.oss().get(0).name()))
                .keypairId(keypair.keypairId())
                .cycle("m")
                .sshAndConsoleUser("adminuser")
                .consolePassword("s3cretP4ssw0rd")
                .build());

        ctx.export("vmStatus", vm.status());
    }
}

name: biznetgio
runtime: yaml
description: "Keypair + VM NEO Lite pake function products & osList."
variables:
  products:
    fn::invoke:
      function: biznetgio:index:neoliteProducts
      return: products
  osList:
    fn::invoke:
      function: biznetgio:index:neoliteOsList
      arguments:
        productId: ${products[0].productId}
      return: oss
resources:
  keypair:
    type: biznetgio:index:NeoliteKeypair
    properties:
      name: neo-lite-key
  vm:
    type: biznetgio:index:NeoliteVm
    properties:
      vmName: neo-lite-1
      productId: ${products[0].productId}
      selectOs: ${osList[0].name}
      keypairId: ${keypair.keypairId}
      cycle: m
      sshAndConsoleUser: adminuser
      consolePassword: s3cretP4ssw0rd
outputs:
  vmStatus: ${vm.status}

products[0] and oss[0] take whichever product and OS the API happens to list first - not necessarily the cheapest or smallest one. This quickstart uses them so you have something that runs in one copy-paste, but before you leave this as-is on an account you care about the cost of, read Understanding the product catalog and replace [0] with a filter for the exact package (for example the cheapest NEO Lite tier, XS 1.1) and OS you actually want - see the NEO Lite catalog for the full pricing table and a copy-paste filter in TypeScript.

This step places a real order at whatever price the first-listed product happens to be. If you want to guarantee the lowest cost before running pulumi up, do the filtering in Picking a specific package first.

Deploy

pulumi up

Confirm with yes. Creating the VM places a real order on your account; the provider polls until the VM reports Active (typically 1-5 minutes).

Verify

pulumi stack output vmStatus

You should see "Active". Your VM is also visible under NEO Lite in the portal.

Clean up

pulumi destroy

Destroying the VM resource deletes the server.

Next steps

Product Catalog - real NEO Lite pricing and how to pick an exact package instead of [0]
Pulumi installation - all five language SDKs and configuration
NEO Lite resources - every NEO Lite resource and function
Billing - how orders and payment work

Stuck? Open an issue on the provider repository, or contact Biznet GIO support at support@biznetgio.com.

Getting Started

Tutorials

Terraform Provider

Pulumi Provider

Guides

About

Prerequisites

Get started

Next steps

​Prerequisites

​Get started

​Next steps

Prerequisites

Get started

Next steps