Quickstart (Pulumi)

Order a NEO Lite VM with the Biznet GIO Pulumi provider

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

1. Create a project

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

   TypeScript

   npm install @shirasakaren/biznetgio
   

   Python

   pip install pulumi-biznetgio
   

   Go

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

   .NET

   dotnet add package Shirasakaren.Biznetgio
   

   Java

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

   YAML

   No SDK needed - YAML programs use the provider directly.

2. Set your API token

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

   Alternatively export BIZNETGIO_API_KEY.

3. Write the program

   TypeScript

   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: "admin",
     consolePassword: "s3cretP4ssw0rd",
   });
   
   export const vmStatus = vm.status;
   

   Python

   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="admin",
       console_password="s3cretP4ssw0rd",
   )
   
   pulumi.export("vmStatus", vm.status)
   

   Go

   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("admin"),
               ConsolePassword:   pulumi.String("s3cretP4ssw0rd"),
           })
           if err != nil {
               return err
           }
   
           ctx.Export("vmStatus", vm.Status)
           return nil
       })
   }
   

   .NET

   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 = "admin",
           ConsolePassword = "s3cretP4ssw0rd",
       });
   
       return new Dictionary<string, object?>
       {
           ["vmStatus"] = vm.Status,
       };
   });
   

   Java

   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("admin")
                   .consolePassword("s3cretP4ssw0rd")
                   .build());
   
           ctx.export("vmStatus", vm.status());
       }
   }
   

   YAML

   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: admin
         consolePassword: s3cretP4ssw0rd
   outputs:
     vmStatus: ${vm.status}
   
4. 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).

5. Verify

   pulumi stack output vmStatus
   

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

6. Clean up

   pulumi destroy
   

   Destroying the VM resource deletes the server.

Next steps

• 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 [e-mail].