pulumi-gcp-kotlin/com.pulumi.gcp.blockchainnodeengine.kotlin/BlockchainNodes

BlockchainNodes

class BlockchainNodes : KotlinCustomResource

A representation of a blockchain node. To get more information about BlockchainNodes, see:

Example Usage

Blockchain Nodes Basic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const defaultNode = new gcp.blockchainnodeengine.BlockchainNodes("default_node", {
    location: "us-central1",
    blockchainType: "ETHEREUM",
    blockchainNodeId: "blockchain_basic_node",
    ethereumDetails: {
        apiEnableAdmin: true,
        apiEnableDebug: true,
        validatorConfig: {
            mevRelayUrls: [
                "https://mev1.example.org/",
                "https://mev2.example.org/",
            ],
        },
        nodeType: "ARCHIVE",
        consensusClient: "LIGHTHOUSE",
        executionClient: "ERIGON",
        network: "MAINNET",
    },
    labels: {
        environment: "dev",
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
default_node = gcp.blockchainnodeengine.BlockchainNodes("default_node",
    location="us-central1",
    blockchain_type="ETHEREUM",
    blockchain_node_id="blockchain_basic_node",
    ethereum_details={
        "api_enable_admin": True,
        "api_enable_debug": True,
        "validator_config": {
            "mev_relay_urls": [
                "https://mev1.example.org/",
                "https://mev2.example.org/",
            ],
        },
        "node_type": "ARCHIVE",
        "consensus_client": "LIGHTHOUSE",
        "execution_client": "ERIGON",
        "network": "MAINNET",
    },
    labels={
        "environment": "dev",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var defaultNode = new Gcp.BlockchainNodeEngine.BlockchainNodes("default_node", new()
    {
        Location = "us-central1",
        BlockchainType = "ETHEREUM",
        BlockchainNodeId = "blockchain_basic_node",
        EthereumDetails = new Gcp.BlockchainNodeEngine.Inputs.BlockchainNodesEthereumDetailsArgs
        {
            ApiEnableAdmin = true,
            ApiEnableDebug = true,
            ValidatorConfig = new Gcp.BlockchainNodeEngine.Inputs.BlockchainNodesEthereumDetailsValidatorConfigArgs
            {
                MevRelayUrls = new[]
                {
                    "https://mev1.example.org/",
                    "https://mev2.example.org/",
                },
            },
            NodeType = "ARCHIVE",
            ConsensusClient = "LIGHTHOUSE",
            ExecutionClient = "ERIGON",
            Network = "MAINNET",
        },
        Labels =
        {
            { "environment", "dev" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/blockchainnodeengine"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := blockchainnodeengine.NewBlockchainNodes(ctx, "default_node", &blockchainnodeengine.BlockchainNodesArgs{
			Location:         pulumi.String("us-central1"),
			BlockchainType:   pulumi.String("ETHEREUM"),
			BlockchainNodeId: pulumi.String("blockchain_basic_node"),
			EthereumDetails: &blockchainnodeengine.BlockchainNodesEthereumDetailsArgs{
				ApiEnableAdmin: pulumi.Bool(true),
				ApiEnableDebug: pulumi.Bool(true),
				ValidatorConfig: &blockchainnodeengine.BlockchainNodesEthereumDetailsValidatorConfigArgs{
					MevRelayUrls: pulumi.StringArray{
						pulumi.String("https://mev1.example.org/"),
						pulumi.String("https://mev2.example.org/"),
					},
				},
				NodeType:        pulumi.String("ARCHIVE"),
				ConsensusClient: pulumi.String("LIGHTHOUSE"),
				ExecutionClient: pulumi.String("ERIGON"),
				Network:         pulumi.String("MAINNET"),
			},
			Labels: pulumi.StringMap{
				"environment": pulumi.String("dev"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.blockchainnodeengine.BlockchainNodes;
import com.pulumi.gcp.blockchainnodeengine.BlockchainNodesArgs;
import com.pulumi.gcp.blockchainnodeengine.inputs.BlockchainNodesEthereumDetailsArgs;
import com.pulumi.gcp.blockchainnodeengine.inputs.BlockchainNodesEthereumDetailsValidatorConfigArgs;
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 defaultNode = new BlockchainNodes("defaultNode", BlockchainNodesArgs.builder()
            .location("us-central1")
            .blockchainType("ETHEREUM")
            .blockchainNodeId("blockchain_basic_node")
            .ethereumDetails(BlockchainNodesEthereumDetailsArgs.builder()
                .apiEnableAdmin(true)
                .apiEnableDebug(true)
                .validatorConfig(BlockchainNodesEthereumDetailsValidatorConfigArgs.builder()
                    .mevRelayUrls(
                        "https://mev1.example.org/",
                        "https://mev2.example.org/")
                    .build())
                .nodeType("ARCHIVE")
                .consensusClient("LIGHTHOUSE")
                .executionClient("ERIGON")
                .network("MAINNET")
                .build())
            .labels(Map.of("environment", "dev"))
            .build());
    }
}
Content copied to clipboard
resources:
  defaultNode:
    type: gcp:blockchainnodeengine:BlockchainNodes
    name: default_node
    properties:
      location: us-central1
      blockchainType: ETHEREUM
      blockchainNodeId: blockchain_basic_node
      ethereumDetails:
        apiEnableAdmin: true
        apiEnableDebug: true
        validatorConfig:
          mevRelayUrls:
            - https://mev1.example.org/
            - https://mev2.example.org/
        nodeType: ARCHIVE
        consensusClient: LIGHTHOUSE
        executionClient: ERIGON
        network: MAINNET
      labels:
        environment: dev
Content copied to clipboard

Blockchain Nodes Geth Details

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const defaultNodeGeth = new gcp.blockchainnodeengine.BlockchainNodes("default_node_geth", {
    location: "us-central1",
    blockchainType: "ETHEREUM",
    blockchainNodeId: "blockchain_geth_node",
    ethereumDetails: {
        apiEnableAdmin: true,
        apiEnableDebug: true,
        validatorConfig: {
            mevRelayUrls: [
                "https://mev1.example.org/",
                "https://mev2.example.org/",
            ],
        },
        nodeType: "FULL",
        consensusClient: "LIGHTHOUSE",
        executionClient: "GETH",
        network: "MAINNET",
        gethDetails: {
            garbageCollectionMode: "FULL",
        },
    },
    labels: {
        environment: "dev",
    },
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
default_node_geth = gcp.blockchainnodeengine.BlockchainNodes("default_node_geth",
    location="us-central1",
    blockchain_type="ETHEREUM",
    blockchain_node_id="blockchain_geth_node",
    ethereum_details={
        "api_enable_admin": True,
        "api_enable_debug": True,
        "validator_config": {
            "mev_relay_urls": [
                "https://mev1.example.org/",
                "https://mev2.example.org/",
            ],
        },
        "node_type": "FULL",
        "consensus_client": "LIGHTHOUSE",
        "execution_client": "GETH",
        "network": "MAINNET",
        "geth_details": {
            "garbage_collection_mode": "FULL",
        },
    },
    labels={
        "environment": "dev",
    })
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var defaultNodeGeth = new Gcp.BlockchainNodeEngine.BlockchainNodes("default_node_geth", new()
    {
        Location = "us-central1",
        BlockchainType = "ETHEREUM",
        BlockchainNodeId = "blockchain_geth_node",
        EthereumDetails = new Gcp.BlockchainNodeEngine.Inputs.BlockchainNodesEthereumDetailsArgs
        {
            ApiEnableAdmin = true,
            ApiEnableDebug = true,
            ValidatorConfig = new Gcp.BlockchainNodeEngine.Inputs.BlockchainNodesEthereumDetailsValidatorConfigArgs
            {
                MevRelayUrls = new[]
                {
                    "https://mev1.example.org/",
                    "https://mev2.example.org/",
                },
            },
            NodeType = "FULL",
            ConsensusClient = "LIGHTHOUSE",
            ExecutionClient = "GETH",
            Network = "MAINNET",
            GethDetails = new Gcp.BlockchainNodeEngine.Inputs.BlockchainNodesEthereumDetailsGethDetailsArgs
            {
                GarbageCollectionMode = "FULL",
            },
        },
        Labels =
        {
            { "environment", "dev" },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/blockchainnodeengine"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := blockchainnodeengine.NewBlockchainNodes(ctx, "default_node_geth", &blockchainnodeengine.BlockchainNodesArgs{
			Location:         pulumi.String("us-central1"),
			BlockchainType:   pulumi.String("ETHEREUM"),
			BlockchainNodeId: pulumi.String("blockchain_geth_node"),
			EthereumDetails: &blockchainnodeengine.BlockchainNodesEthereumDetailsArgs{
				ApiEnableAdmin: pulumi.Bool(true),
				ApiEnableDebug: pulumi.Bool(true),
				ValidatorConfig: &blockchainnodeengine.BlockchainNodesEthereumDetailsValidatorConfigArgs{
					MevRelayUrls: pulumi.StringArray{
						pulumi.String("https://mev1.example.org/"),
						pulumi.String("https://mev2.example.org/"),
					},
				},
				NodeType:        pulumi.String("FULL"),
				ConsensusClient: pulumi.String("LIGHTHOUSE"),
				ExecutionClient: pulumi.String("GETH"),
				Network:         pulumi.String("MAINNET"),
				GethDetails: &blockchainnodeengine.BlockchainNodesEthereumDetailsGethDetailsArgs{
					GarbageCollectionMode: pulumi.String("FULL"),
				},
			},
			Labels: pulumi.StringMap{
				"environment": pulumi.String("dev"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.blockchainnodeengine.BlockchainNodes;
import com.pulumi.gcp.blockchainnodeengine.BlockchainNodesArgs;
import com.pulumi.gcp.blockchainnodeengine.inputs.BlockchainNodesEthereumDetailsArgs;
import com.pulumi.gcp.blockchainnodeengine.inputs.BlockchainNodesEthereumDetailsValidatorConfigArgs;
import com.pulumi.gcp.blockchainnodeengine.inputs.BlockchainNodesEthereumDetailsGethDetailsArgs;
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 defaultNodeGeth = new BlockchainNodes("defaultNodeGeth", BlockchainNodesArgs.builder()
            .location("us-central1")
            .blockchainType("ETHEREUM")
            .blockchainNodeId("blockchain_geth_node")
            .ethereumDetails(BlockchainNodesEthereumDetailsArgs.builder()
                .apiEnableAdmin(true)
                .apiEnableDebug(true)
                .validatorConfig(BlockchainNodesEthereumDetailsValidatorConfigArgs.builder()
                    .mevRelayUrls(
                        "https://mev1.example.org/",
                        "https://mev2.example.org/")
                    .build())
                .nodeType("FULL")
                .consensusClient("LIGHTHOUSE")
                .executionClient("GETH")
                .network("MAINNET")
                .gethDetails(BlockchainNodesEthereumDetailsGethDetailsArgs.builder()
                    .garbageCollectionMode("FULL")
                    .build())
                .build())
            .labels(Map.of("environment", "dev"))
            .build());
    }
}
Content copied to clipboard
resources:
  defaultNodeGeth:
    type: gcp:blockchainnodeengine:BlockchainNodes
    name: default_node_geth
    properties:
      location: us-central1
      blockchainType: ETHEREUM
      blockchainNodeId: blockchain_geth_node
      ethereumDetails:
        apiEnableAdmin: true
        apiEnableDebug: true
        validatorConfig:
          mevRelayUrls:
            - https://mev1.example.org/
            - https://mev2.example.org/
        nodeType: FULL
        consensusClient: LIGHTHOUSE
        executionClient: GETH
        network: MAINNET
        gethDetails:
          garbageCollectionMode: FULL
      labels:
        environment: dev
Content copied to clipboard

Import

BlockchainNodes can be imported using any of these accepted formats:

  • projects/{{project}}/locations/{{location}}/blockchainNodes/{{blockchain_node_id}}

  • {{project}}/{{location}}/{{blockchain_node_id}}

  • {{location}}/{{blockchain_node_id}} When using the pulumi import command, BlockchainNodes can be imported using one of the formats above. For example:

$ pulumi import gcp:blockchainnodeengine/blockchainNodes:BlockchainNodes default projects/{{project}}/locations/{{location}}/blockchainNodes/{{blockchain_node_id}}
Content copied to clipboard
$ pulumi import gcp:blockchainnodeengine/blockchainNodes:BlockchainNodes default {{project}}/{{location}}/{{blockchain_node_id}}
Content copied to clipboard
$ pulumi import gcp:blockchainnodeengine/blockchainNodes:BlockchainNodes default {{location}}/{{blockchain_node_id}}
Content copied to clipboard

Properties

Link copied to clipboard
val blockchainNodeId: Output<String>

ID of the requesting object.

Link copied to clipboard
val blockchainType: Output<String>?

User-provided key-value pairs Possible values are: ETHEREUM.

Link copied to clipboard
val connectionInfos: Output<List<BlockchainNodesConnectionInfo>>

The connection information through which to interact with a blockchain node. Structure is documented below.

Link copied to clipboard
val createTime: Output<String>

The timestamp at which the blockchain node was first created.

Link copied to clipboard
val effectiveLabels: Output<Map<String, String>>

All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.

Link copied to clipboard
val ethereumDetails: Output<BlockchainNodesEthereumDetails>?

User-provided key-value pairs Structure is documented below.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val labels: Output<Map<String, String>>?

User-provided key-value pairs Note: This field is non-authoritative, and will only manage the labels present in your configuration. Please refer to the field effective_labels for all of the labels present on the resource.

Link copied to clipboard
val location: Output<String>

Location of Blockchain Node being created.

Link copied to clipboard
val name: Output<String>

The fully qualified name of the blockchain node. e.g. projects/my-project/locations/us-central1/blockchainNodes/my-node.

Link copied to clipboard
val project: Output<String>

The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
val pulumiLabels: Output<Map<String, String>>

The combination of labels configured directly on the resource and default labels configured on the provider.

Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val updateTime: Output<String>

The timestamp at which the blockchain node was last updated.

Link copied to clipboard
val urn: Output<String>