civo.Volume

import * as pulumi from "@pulumi/pulumi";
import * as civo from "@pulumi/civo";

const defaultNetwork = civo.getNetwork({
    label: "Default",
});
// Create volume
const db = new civo.Volume("db", {
    sizeGb: 5,
    networkId: defaultNetwork.then(defaultNetwork => defaultNetwork.id),
}, {
    dependsOn: [defaultNetwork],
});

import pulumi
import pulumi_civo as civo

default_network = civo.get_network(label="Default")
# Create volume
db = civo.Volume("db",
    size_gb=5,
    network_id=default_network.id,
    opts=pulumi.ResourceOptions(depends_on=[default_network]))

package main

import (
	"github.com/pulumi/pulumi-civo/sdk/v2/go/civo"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		defaultNetwork, err := civo.LookupNetwork(ctx, &civo.LookupNetworkArgs{
			Label: pulumi.StringRef("Default"),
		}, nil)
		if err != nil {
			return err
		}
		// Create volume
		_, err = civo.NewVolume(ctx, "db", &civo.VolumeArgs{
			SizeGb:    pulumi.Int(5),
			NetworkId: pulumi.String(defaultNetwork.Id),
		}, pulumi.DependsOn([]pulumi.Resource{
			defaultNetwork,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Civo = Pulumi.Civo;

return await Deployment.RunAsync(() => 
{
    var defaultNetwork = Civo.GetNetwork.Invoke(new()
    {
        Label = "Default",
    });

    // Create volume
    var db = new Civo.Volume("db", new()
    {
        SizeGb = 5,
        NetworkId = defaultNetwork.Apply(getNetworkResult => getNetworkResult.Id),
    }, new CustomResourceOptions
    {
        DependsOn = new[]
        {
            defaultNetwork,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.civo.CivoFunctions;
import com.pulumi.civo.inputs.GetNetworkArgs;
import com.pulumi.civo.Volume;
import com.pulumi.civo.VolumeArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        final var defaultNetwork = CivoFunctions.getNetwork(GetNetworkArgs.builder()
            .label("Default")
            .build());

        var db = new Volume("db", VolumeArgs.builder()        
            .sizeGb(5)
            .networkId(defaultNetwork.applyValue(getNetworkResult -> getNetworkResult.id()))
            .build(), CustomResourceOptions.builder()
                .dependsOn(defaultNetwork.applyValue(getNetworkResult -> getNetworkResult))
                .build());

    }
}

resources:
  # Create volume
  db:
    type: civo:Volume
    properties:
      sizeGb: 5
      networkId: ${defaultNetwork.id}
    options:
      dependson:
        - ${defaultNetwork}
variables:
  defaultNetwork:
    fn::invoke:
      Function: civo:getNetwork
      Arguments:
        label: Default

var volumeResource = new Civo.Volume("volumeResource", new()
{
    NetworkId = "string",
    SizeGb = 0,
    Name = "string",
    Region = "string",
});

example, err := civo.NewVolume(ctx, "volumeResource", &civo.VolumeArgs{
	NetworkId: pulumi.String("string"),
	SizeGb:    pulumi.Int(0),
	Name:      pulumi.String("string"),
	Region:    pulumi.String("string"),
})

var volumeResource = new Volume("volumeResource", VolumeArgs.builder()        
    .networkId("string")
    .sizeGb(0)
    .name("string")
    .region("string")
    .build());

volume_resource = civo.Volume("volumeResource",
    network_id="string",
    size_gb=0,
    name="string",
    region="string")

const volumeResource = new civo.Volume("volumeResource", {
    networkId: "string",
    sizeGb: 0,
    name: "string",
    region: "string",
});

type: civo:Volume
properties:
    name: string
    networkId: string
    region: string
    sizeGb: 0