gcp.compute.DiskAsyncReplication

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

return await Deployment.RunAsync(() => 
{
    var primary_disk = new Gcp.Compute.Disk("primary-disk", new()
    {
        Type = "pd-ssd",
        Zone = "europe-west4-a",
        PhysicalBlockSizeBytes = 4096,
    });

    var secondary_disk = new Gcp.Compute.Disk("secondary-disk", new()
    {
        Type = "pd-ssd",
        Zone = "europe-west3-a",
        AsyncPrimaryDisk = new Gcp.Compute.Inputs.DiskAsyncPrimaryDiskArgs
        {
            Disk = primary_disk.Id,
        },
        PhysicalBlockSizeBytes = 4096,
    });

    var replication = new Gcp.Compute.DiskAsyncReplication("replication", new()
    {
        PrimaryDisk = primary_disk.Id,
        SecondaryDisk = new Gcp.Compute.Inputs.DiskAsyncReplicationSecondaryDiskArgs
        {
            Disk = secondary_disk.Id,
        },
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v6/go/gcp/compute"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := compute.NewDisk(ctx, "primary-disk", &compute.DiskArgs{
			Type:                   pulumi.String("pd-ssd"),
			Zone:                   pulumi.String("europe-west4-a"),
			PhysicalBlockSizeBytes: pulumi.Int(4096),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewDisk(ctx, "secondary-disk", &compute.DiskArgs{
			Type: pulumi.String("pd-ssd"),
			Zone: pulumi.String("europe-west3-a"),
			AsyncPrimaryDisk: &compute.DiskAsyncPrimaryDiskArgs{
				Disk: primary_disk.ID(),
			},
			PhysicalBlockSizeBytes: pulumi.Int(4096),
		})
		if err != nil {
			return err
		}
		_, err = compute.NewDiskAsyncReplication(ctx, "replication", &compute.DiskAsyncReplicationArgs{
			PrimaryDisk: primary_disk.ID(),
			SecondaryDisk: &compute.DiskAsyncReplicationSecondaryDiskArgs{
				Disk: secondary_disk.ID(),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.compute.Disk;
import com.pulumi.gcp.compute.DiskArgs;
import com.pulumi.gcp.compute.inputs.DiskAsyncPrimaryDiskArgs;
import com.pulumi.gcp.compute.DiskAsyncReplication;
import com.pulumi.gcp.compute.DiskAsyncReplicationArgs;
import com.pulumi.gcp.compute.inputs.DiskAsyncReplicationSecondaryDiskArgs;
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) {
        var primary_disk = new Disk("primary-disk", DiskArgs.builder()        
            .type("pd-ssd")
            .zone("europe-west4-a")
            .physicalBlockSizeBytes(4096)
            .build());

        var secondary_disk = new Disk("secondary-disk", DiskArgs.builder()        
            .type("pd-ssd")
            .zone("europe-west3-a")
            .asyncPrimaryDisk(DiskAsyncPrimaryDiskArgs.builder()
                .disk(primary_disk.id())
                .build())
            .physicalBlockSizeBytes(4096)
            .build());

        var replication = new DiskAsyncReplication("replication", DiskAsyncReplicationArgs.builder()        
            .primaryDisk(primary_disk.id())
            .secondaryDisk(DiskAsyncReplicationSecondaryDiskArgs.builder()
                .disk(secondary_disk.id())
                .build())
            .build());

    }
}

import pulumi
import pulumi_gcp as gcp

primary_disk = gcp.compute.Disk("primary-disk",
    type="pd-ssd",
    zone="europe-west4-a",
    physical_block_size_bytes=4096)
secondary_disk = gcp.compute.Disk("secondary-disk",
    type="pd-ssd",
    zone="europe-west3-a",
    async_primary_disk=gcp.compute.DiskAsyncPrimaryDiskArgs(
        disk=primary_disk.id,
    ),
    physical_block_size_bytes=4096)
replication = gcp.compute.DiskAsyncReplication("replication",
    primary_disk=primary_disk.id,
    secondary_disk=gcp.compute.DiskAsyncReplicationSecondaryDiskArgs(
        disk=secondary_disk.id,
    ))

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

const primary_disk = new gcp.compute.Disk("primary-disk", {
    type: "pd-ssd",
    zone: "europe-west4-a",
    physicalBlockSizeBytes: 4096,
});
const secondary_disk = new gcp.compute.Disk("secondary-disk", {
    type: "pd-ssd",
    zone: "europe-west3-a",
    asyncPrimaryDisk: {
        disk: primary_disk.id,
    },
    physicalBlockSizeBytes: 4096,
});
const replication = new gcp.compute.DiskAsyncReplication("replication", {
    primaryDisk: primary_disk.id,
    secondaryDisk: {
        disk: secondary_disk.id,
    },
});

resources:
  primary-disk:
    type: gcp:compute:Disk
    properties:
      type: pd-ssd
      zone: europe-west4-a
      physicalBlockSizeBytes: 4096
  secondary-disk:
    type: gcp:compute:Disk
    properties:
      type: pd-ssd
      zone: europe-west3-a
      asyncPrimaryDisk:
        disk: ${["primary-disk"].id}
      physicalBlockSizeBytes: 4096
  replication:
    type: gcp:compute:DiskAsyncReplication
    properties:
      primaryDisk: ${["primary-disk"].id}
      secondaryDisk:
        disk: ${["secondary-disk"].id}