Complete code walkthrough

​

Part 1: the Terraform repo

​

1.1 The five-file anatomy

terraform {
  required_version = ">= 1.0"

  required_providers {
    biznetgio = {
      source  = "registry.terraform.io/shirasakaren/biznetgio"
      version = "0.1.0"
    }
  }
}

provider "biznetgio" {}

• required_version is the minimum Terraform CLI version. The provider itself uses the Terraform Plugin Framework.
• required_providers maps the local name biznetgio to a registry address and pins the version. terraform init downloads exactly 0.1.0 from the Terraform Registry.
• The empty provider "biznetgio" block configures the provider with zero inline arguments. The provider reads the BIZNETGIO_API_KEY environment variable itself, which is why no token ever appears in a file.

• ssh_and_console_user: string, default "adminuser" (or "root" in gpu/). The comments note the API rule: 6 to 32 characters, letters, numbers, dash, dot only.
• console_password: string, sensitive = true, deliberately no default. The only ways in are TF_VAR_console_password or the gitignored terraform.tfvars. This exists in neolite/, neolite-pro/, gpu/, and complete/; baremetal/ and object-storage/ authenticate with a keypair only and have no such variable.
• pay_with_credit_card: bool, default false. false still creates the real resource, it just leaves the invoice unpaid in the portal. See Billing and orders.

• data blocks are read-only lookups. data "biznetgio_neolite_products" "all" {} queries the API for the current catalog; the result is referenced as data.biznetgio_neolite_products.all.products[0].product_id.
• resource blocks create and manage things. References between them, like keypair_id = biznetgio_neolite_keypair.main.keypair_id, are what Terraform turns into a dependency graph and an API call order.
• locals blocks compute values once, like picking products[0] for the demo.

​

1.2 neolite/: the full NEO Lite story

​

1.3 neolite-pro/: same shape, dedicated tier

• No biznetgio_neolite_pro_vm_from_snapshot exists. Pro snapshots restore only through the portal today; the file’s banner says so.
• biznetgio_neolite_pro_disk.extra has a 30 GB minimum instead of 60 GB, service_name = "pro-extra-disk", same product_id = 60.
• vm_name = "pro-example" (the shorter name also fits the 6 to 16 character limit).
• Migration into Pro comes from the Lite side via migrate_to_pro on the neolite/ example.
• Outputs are the same set minus restored_vm_status.

​

1.4 baremetal/: dedicated hardware

​

1.5 gpu/: the two quirks, concretely

resource "biznetgio_gpu_keypair" "main" {
  name = "gpu-example-key"
}

resource "biznetgio_gpu_instance" "main" {
  product_id           = local.gpu_product_id
  select_os            = "ubuntu-22"
  keypair_id           = biznetgio_gpu_keypair.main.id
  service_name         = "gpu-example"
  ssh_and_console_user = var.ssh_and_console_user
  console_password     = var.console_password
  pay_with_credit_card = var.pay_with_credit_card

  subscription = {
    cycle = "m"
  }
}

• biznetgio_gpu_keypair exports no keypair_id attribute. It exports id (which already is the keypair id), public_key, and private_key. The instance references .id.
• subscription and on_demand are object-typed attributes, not blocks. They are assigned with = and exactly one of the two must be set; Terraform rejects a plan with neither or both. The commented-out on_demand form is on_demand = { additional_hours = 0 } and bills hourly. Two one-shot triggers are commented out: rebuild_trigger (wipes the disk) and reserve_additional_hours_trigger.

​

1.6 object-storage/: S3-compatible storage

​

1.7 complete/: the module

• main.tf declares five resources: biznetgio_neolite_pro_keypair.this (named "${var.name}-key"), biznetgio_neolite_pro_vm.this (vm_name = var.name), biznetgio_object_storage.this, biznetgio_object_storage_bucket.this ("${var.name}-assets", acl = "private"), and biznetgio_object_storage_credential.this. All references use the module’s own resources, so the module is fully self-contained.
• variables.tf declares ten inputs: name (VM name and prefix for bucket and credential, 6 to 16 characters), storage_label (separate on purpose because the storage label has its own 6 to 16 character limit), vm_product_id, select_os, storage_product_id, cycle (default "m"), ssh_and_console_user (default "adminuser"), console_password (sensitive, no default), pay_with_credit_card (default false), storage_quota (default 10).
• outputs.tf exports vm_status, bucket_name, access_key (sensitive), secret_key (sensitive), keypair_private_key (sensitive). The comment on the sensitive ones says the module caller owns the responsibility of saving them.
• Its own terraform { required_providers { biznetgio = { source = "registry.terraform.io/shirasakaren/biznetgio" } } } block. Without it, Terraform assumes the default hashicorp/* namespace for providers referenced inside a child module and fails with a missing provider error. Any module copied out of this repo must keep that block.

​

1.8 The workflow

​

Part 2: the Pulumi repo

​

2.1 Project anatomy per language

name: biznetgio-example-neolite
runtime: nodejs
description: NEO Lite walkthrough - every resource and data source this service has

​

2.2 The shared program model

1. Config. Read the stack settings. consolePassword is required and secret (config.requireSecret("consolePassword"), cfg.RequireSecret(...), config.require_secret(...)); payWithCreditCard is optional boolean defaulting to false. Set them with pulumi config set --secret consolePassword <value>.
2. Catalog lookups. Invoke the product catalog, then the OS list for the first product, sometimes IP availability. Functions are read-only API calls.
3. Resources. Create the keypair, the VM, and everything else. Passing one resource’s output into another’s input is what builds the dependency graph.
4. Outputs. Export the values you care about.
5. Run. Each language has its own entry mechanism: TypeScript and Python run top-level; Go wraps everything in pulumi.Run(func(ctx *pulumi.Context) error {...}) with (value, error) returns on every call; .NET uses top-level statements returning await Deployment.RunAsync(() => {...}) and exports via a returned Dictionary<string, object?>; Java wraps in Pulumi.run(App::stack) with ctx.export(...) calls; YAML declares configuration, variables, resources, and outputs sections instead of code.

​

2.3 The account id conversion

function toAccountId(id: pulumi.Input<string>): pulumi.Output<number> {
  return pulumi.output(id).apply((value) => Number(value));
}

def to_account_id(value: pulumi.Input[str]) -> pulumi.Output[int]:
    return pulumi.Output.from_input(value).apply(int)

func toAccountID(id pulumi.IDOutput) pulumi.IntOutput {
	return id.ToStringOutput().ApplyT(func(s string) (int, error) {
		return strconv.Atoi(s)
	}).(pulumi.IntOutput)
}

static Output<int> ToAccountId(Output<string> id) => id.Apply(v => int.Parse(v));

private static Output<Integer> toAccountId(Output<String> id) {
    return id.applyValue(Integer::parseInt);
}

neoliteAccountId: ${fn::toNumber(vm.id)}

• keypairId on the VPS and baremetal VMs is string-typed: NeoliteKeypair, NeoliteProKeypair, and BaremetalKeypair all expose a string keypairId that passes straight through.
• Every Object Storage accountId (ObjectStorageBucket, ObjectStorageCredential, ObjectStorageObject, and the three catalog functions) is string-typed. No conversion anywhere in object-storage/ or complete/.
• GpuConsole and GpuGraph take accountId as a string; the GPU examples pass gpu.id directly.
• GpuKeypair exposes no keypairId at all, only id, publicKey, and privateKey. The GPU examples convert keypair.id with the same helper (inline, as keypair.id.apply((id) => Number(id)) in TypeScript, keypair_id = keypair.id.apply(int) in Python, and equivalents elsewhere) and comment why.

​

2.4 The examples, inventory per product line

​

2.5 The complete/ example and the component

• Registration with the type string "biznetgio-example:index:AppStack".
• Five children: keypair, VM, storage, bucket, credential, each named ${name}-key, ${name}-vm, ${name}-storage, ${name}-assets, ${name}-cred.
• Each child gets the component as parent: { parent: this } (TypeScript), opts=pulumi.ResourceOptions(parent=self) (Python), pulumi.Parent(app) (Go), new CustomResourceOptions { Parent = this } (.NET), CustomResourceOptions.builder().parent(this).build() (Java). The parent wiring groups everything under one tree so pulumi destroy tears the whole app down in order.
• Outputs are published with registerOutputs({...}) (TypeScript), self.register_outputs({...}) (Python), ctx.RegisterResourceOutputs(app, pulumi.Map{...}) (Go), RegisterOutputs(new Dictionary<string, object?>{...}) (.NET), this.registerOutputs(Map.of(...)) (Java).
• Args: TypeScript uses an AppStackArgs interface; Python a plain class with storage_quota defaulting to None and the component falling back to 10; Go a struct with StorageQuota *int where nil means the 10 GB default; .NET a class with nullable Input<int>? StorageQuota and args.StorageQuota ?? 10; Java a builder class (AppStackArgs.java) where storageQuota defaults to Input.of(10); the bucket acl is private and the VM vmName is the component name itself.

​

2.6 The workflow

​

Part 3: cross-cutting technical reference

​

The billing model

​

The one-shot and destructive options

​

Side-effecting reads

​

Name limits enforced by the API

​

Secrets per tool

​

Part 4: complete file indexes