> ## Documentation Index
> Fetch the complete documentation index at: https://biznetgio.creations.ren/llms.txt
> Use this file to discover all available pages before exploring further.

# 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](https://www.pulumi.com/docs/iac/cli/) installed
* A [Biznet GIO](https://biznetgio.com) account
* An API token - see [Authentication](/authentication)

## Get started

<Steps>
  <Step title="Create a project">
    ```bash theme={null}
    mkdir biznetgio-demo && cd biznetgio-demo
    pulumi new typescript
    ```

    <Tabs>
      <Tab title="TypeScript">
        ```bash theme={null}
        npm install @shirasakaren/biznetgio
        ```
      </Tab>

      <Tab title="Python">
        ```bash theme={null}
        pip install pulumi-biznetgio
        ```
      </Tab>

      <Tab title="Go">
        ```bash theme={null}
        go get github.com/shirasakaren/pulumi-biznetgio/sdk/go/pulumi-biznetgio
        ```
      </Tab>

      <Tab title=".NET">
        ```bash theme={null}
        dotnet add package Shirasakaren.Biznetgio
        ```
      </Tab>

      <Tab title="Java">
        ```bash theme={null}
        # build.gradle
        # implementation("ren.shirasaka:biznetgio:0.1.5")
        ```
      </Tab>

      <Tab title="YAML">
        No SDK needed - YAML programs use the provider directly.
      </Tab>
    </Tabs>
  </Step>

  <Step title="Set your API token">
    ```bash theme={null}
    pulumi config set --secret biznetgio:apiToken <your-token>
    ```

    Alternatively export `BIZNETGIO_API_KEY`.
  </Step>

  <Step title="Write the program">
    <Tabs>
      <Tab title="TypeScript">
        ```typescript theme={null}
        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;
        ```
      </Tab>

      <Tab title="Python">
        ```python theme={null}
        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)
        ```
      </Tab>

      <Tab title="Go">
        ```go theme={null}
        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
            })
        }
        ```
      </Tab>

      <Tab title=".NET">
        ```csharp theme={null}
        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,
            };
        });
        ```
      </Tab>

      <Tab title="Java">
        ```java theme={null}
        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());
            }
        }
        ```
      </Tab>

      <Tab title="YAML">
        ```yaml theme={null}
        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}
        ```
      </Tab>
    </Tabs>
  </Step>

  <Step title="Deploy">
    ```bash theme={null}
    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).
  </Step>

  <Step title="Verify">
    ```bash theme={null}
    pulumi stack output vmStatus
    ```

    You should see `"Active"`. Your VM is also visible under NEO Lite in the [portal](https://portal.biznetgio.com).
  </Step>

  <Step title="Clean up">
    ```bash theme={null}
    pulumi destroy
    ```

    Destroying the VM resource deletes the server.
  </Step>
</Steps>

## Next steps

* [Pulumi installation](/pulumi/installation) - all five language SDKs and configuration
* [NEO Lite resources](/pulumi/resources/neolite) - every NEO Lite resource and function
* [Billing](/guides/billing) - how orders and payment work

<Tip>
  Stuck? Open an issue on the [provider repository](https://github.com/shirasakaren/pulumi-biznetgio), or contact Biznet GIO support at [support@biznetgio.com](mailto:support@biznetgio.com).
</Tip>