pulumi-gcp-kotlin/com.pulumi.gcp.osconfig.kotlin/GuestPoliciesArgs

GuestPoliciesArgs

data class GuestPoliciesArgs(val assignment: Output<GuestPoliciesAssignmentArgs>? = null, val description: Output<String>? = null, val etag: Output<String>? = null, val guestPolicyId: Output<String>? = null, val packageRepositories: Output<List<GuestPoliciesPackageRepositoryArgs>>? = null, val packages: Output<List<GuestPoliciesPackageArgs>>? = null, val project: Output<String>? = null, val recipes: Output<List<GuestPoliciesRecipeArgs>>? = null) : ConvertibleToJava<GuestPoliciesArgs>

An OS Config resource representing a guest configuration policy. These policies represent the desired state for VM instance guest environments including packages to install or remove, package repository configurations, and software to install. To get more information about GuestPolicies, see:

Example Usage

Os Config Guest Policies Basic

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const myImage = gcp.compute.getImage({
    family: "debian-11",
    project: "debian-cloud",
});
const foobar = new gcp.compute.Instance("foobar", {
    name: "guest-policy-inst",
    machineType: "e2-medium",
    zone: "us-central1-a",
    canIpForward: false,
    tags: [
        "foo",
        "bar",
    ],
    bootDisk: {
        initializeParams: {
            image: myImage.then(myImage => myImage.selfLink),
        },
    },
    networkInterfaces: [{
        network: "default",
    }],
    metadata: {
        foo: "bar",
    },
});
const guestPolicies = new gcp.osconfig.GuestPolicies("guest_policies", {
    guestPolicyId: "guest-policy",
    assignment: {
        instances: [foobar&#46;id],
    },
    packages: [{
        name: "my-package",
        desiredState: "UPDATED",
    }],
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
my_image = gcp.compute.get_image(family="debian-11",
    project="debian-cloud")
foobar = gcp.compute.Instance("foobar",
    name="guest-policy-inst",
    machine_type="e2-medium",
    zone="us-central1-a",
    can_ip_forward=False,
    tags=[
        "foo",
        "bar",
    ],
    boot_disk={
        "initialize_params": {
            "image": my_image.self_link,
        },
    },
    network_interfaces=[{
        "network": "default",
    }],
    metadata={
        "foo": "bar",
    })
guest_policies = gcp.osconfig.GuestPolicies("guest_policies",
    guest_policy_id="guest-policy",
    assignment={
        "instances": [foobar&#46;id],
    },
    packages=[{
        "name": "my-package",
        "desired_state": "UPDATED",
    }])
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var myImage = Gcp.Compute.GetImage.Invoke(new()
    {
        Family = "debian-11",
        Project = "debian-cloud",
    });
    var foobar = new Gcp.Compute.Instance("foobar", new()
    {
        Name = "guest-policy-inst",
        MachineType = "e2-medium",
        Zone = "us-central1-a",
        CanIpForward = false,
        Tags = new[]
        {
            "foo",
            "bar",
        },
        BootDisk = new Gcp.Compute.Inputs.InstanceBootDiskArgs
        {
            InitializeParams = new Gcp.Compute.Inputs.InstanceBootDiskInitializeParamsArgs
            {
                Image = myImage.Apply(getImageResult => getImageResult.SelfLink),
            },
        },
        NetworkInterfaces = new[]
        {
            new Gcp.Compute.Inputs.InstanceNetworkInterfaceArgs
            {
                Network = "default",
            },
        },
        Metadata =
        {
            { "foo", "bar" },
        },
    });
    var guestPolicies = new Gcp.OsConfig.GuestPolicies("guest_policies", new()
    {
        GuestPolicyId = "guest-policy",
        Assignment = new Gcp.OsConfig.Inputs.GuestPoliciesAssignmentArgs
        {
            Instances = new[]
            {
                foobar.Id,
            },
        },
        Packages = new[]
        {
            new Gcp.OsConfig.Inputs.GuestPoliciesPackageArgs
            {
                Name = "my-package",
                DesiredState = "UPDATED",
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/compute"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/osconfig"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		myImage, err := compute.LookupImage(ctx, &compute.LookupImageArgs{
			Family:  pulumi.StringRef("debian-11"),
			Project: pulumi.StringRef("debian-cloud"),
		}, nil)
		if err != nil {
			return err
		}
		foobar, err := compute.NewInstance(ctx, "foobar", &compute.InstanceArgs{
			Name:         pulumi.String("guest-policy-inst"),
			MachineType:  pulumi.String("e2-medium"),
			Zone:         pulumi.String("us-central1-a"),
			CanIpForward: pulumi.Bool(false),
			Tags: pulumi.StringArray{
				pulumi.String("foo"),
				pulumi.String("bar"),
			},
			BootDisk: &compute.InstanceBootDiskArgs{
				InitializeParams: &compute.InstanceBootDiskInitializeParamsArgs{
					Image: pulumi.String(myImage.SelfLink),
				},
			},
			NetworkInterfaces: compute.InstanceNetworkInterfaceArray{
				&compute.InstanceNetworkInterfaceArgs{
					Network: pulumi.String("default"),
				},
			},
			Metadata: pulumi.StringMap{
				"foo": pulumi.String("bar"),
			},
		})
		if err != nil {
			return err
		}
		_, err = osconfig.NewGuestPolicies(ctx, "guest_policies", &osconfig.GuestPoliciesArgs{
			GuestPolicyId: pulumi.String("guest-policy"),
			Assignment: &osconfig.GuestPoliciesAssignmentArgs{
				Instances: pulumi.StringArray{
					foobar.ID(),
				},
			},
			Packages: osconfig.GuestPoliciesPackageArray{
				&osconfig.GuestPoliciesPackageArgs{
					Name:         pulumi.String("my-package"),
					DesiredState: pulumi.String("UPDATED"),
				},
			},
		})
		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.compute.ComputeFunctions;
import com.pulumi.gcp.compute.inputs.GetImageArgs;
import com.pulumi.gcp.compute.Instance;
import com.pulumi.gcp.compute.InstanceArgs;
import com.pulumi.gcp.compute.inputs.InstanceBootDiskArgs;
import com.pulumi.gcp.compute.inputs.InstanceBootDiskInitializeParamsArgs;
import com.pulumi.gcp.compute.inputs.InstanceNetworkInterfaceArgs;
import com.pulumi.gcp.osconfig.GuestPolicies;
import com.pulumi.gcp.osconfig.GuestPoliciesArgs;
import com.pulumi.gcp.osconfig.inputs.GuestPoliciesAssignmentArgs;
import com.pulumi.gcp.osconfig.inputs.GuestPoliciesPackageArgs;
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 myImage = ComputeFunctions.getImage(GetImageArgs.builder()
            .family("debian-11")
            .project("debian-cloud")
            .build());
        var foobar = new Instance("foobar", InstanceArgs.builder()
            .name("guest-policy-inst")
            .machineType("e2-medium")
            .zone("us-central1-a")
            .canIpForward(false)
            .tags(
                "foo",
                "bar")
            .bootDisk(InstanceBootDiskArgs.builder()
                .initializeParams(InstanceBootDiskInitializeParamsArgs.builder()
                    .image(myImage.applyValue(getImageResult -> getImageResult.selfLink()))
                    .build())
                .build())
            .networkInterfaces(InstanceNetworkInterfaceArgs.builder()
                .network("default")
                .build())
            .metadata(Map.of("foo", "bar"))
            .build());
        var guestPolicies = new GuestPolicies("guestPolicies", GuestPoliciesArgs.builder()
            .guestPolicyId("guest-policy")
            .assignment(GuestPoliciesAssignmentArgs.builder()
                .instances(foobar.id())
                .build())
            .packages(GuestPoliciesPackageArgs.builder()
                .name("my-package")
                .desiredState("UPDATED")
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  foobar:
    type: gcp:compute:Instance
    properties:
      name: guest-policy-inst
      machineType: e2-medium
      zone: us-central1-a
      canIpForward: false
      tags:
        - foo
        - bar
      bootDisk:
        initializeParams:
          image: ${myImage.selfLink}
      networkInterfaces:
        - network: default
      metadata:
        foo: bar
  guestPolicies:
    type: gcp:osconfig:GuestPolicies
    name: guest_policies
    properties:
      guestPolicyId: guest-policy
      assignment:
        instances:
          - ${foobar.id}
      packages:
        - name: my-package
          desiredState: UPDATED
variables:
  myImage:
    fn::invoke:
      Function: gcp:compute:getImage
      Arguments:
        family: debian-11
        project: debian-cloud
Content copied to clipboard

Os Config Guest Policies Packages

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const guestPolicies = new gcp.osconfig.GuestPolicies("guest_policies", {
    guestPolicyId: "guest-policy",
    assignment: {
        groupLabels: [
            {
                labels: {
                    color: "red",
                    env: "test",
                },
            },
            {
                labels: {
                    color: "blue",
                    env: "test",
                },
            },
        ],
    },
    packages: [
        {
            name: "my-package",
            desiredState: "INSTALLED",
        },
        {
            name: "bad-package-1",
            desiredState: "REMOVED",
        },
        {
            name: "bad-package-2",
            desiredState: "REMOVED",
            manager: "APT",
        },
    ],
    packageRepositories: [
        {
            apt: {
                uri: "https://packages.cloud.google.com/apt",
                archiveType: "DEB",
                distribution: "cloud-sdk-stretch",
                components: ["main"],
            },
        },
        {
            yum: {
                id: "google-cloud-sdk",
                displayName: "Google Cloud SDK",
                baseUrl: "https://packages.cloud.google.com/yum/repos/cloud-sdk-el7-x86_64",
                gpgKeys: [
                    "https://packages.cloud.google.com/yum/doc/yum-key.gpg",
                    "https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg",
                ],
            },
        },
    ],
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
guest_policies = gcp.osconfig.GuestPolicies("guest_policies",
    guest_policy_id="guest-policy",
    assignment={
        "group_labels": [
            {
                "labels": {
                    "color": "red",
                    "env": "test",
                },
            },
            {
                "labels": {
                    "color": "blue",
                    "env": "test",
                },
            },
        ],
    },
    packages=[
        {
            "name": "my-package",
            "desired_state": "INSTALLED",
        },
        {
            "name": "bad-package-1",
            "desired_state": "REMOVED",
        },
        {
            "name": "bad-package-2",
            "desired_state": "REMOVED",
            "manager": "APT",
        },
    ],
    package_repositories=[
        {
            "apt": {
                "uri": "https://packages.cloud.google.com/apt",
                "archive_type": "DEB",
                "distribution": "cloud-sdk-stretch",
                "components": ["main"],
            },
        },
        {
            "yum": {
                "id": "google-cloud-sdk",
                "display_name": "Google Cloud SDK",
                "base_url": "https://packages.cloud.google.com/yum/repos/cloud-sdk-el7-x86_64",
                "gpg_keys": [
                    "https://packages.cloud.google.com/yum/doc/yum-key.gpg",
                    "https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg",
                ],
            },
        },
    ])
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var guestPolicies = new Gcp.OsConfig.GuestPolicies("guest_policies", new()
    {
        GuestPolicyId = "guest-policy",
        Assignment = new Gcp.OsConfig.Inputs.GuestPoliciesAssignmentArgs
        {
            GroupLabels = new[]
            {
                new Gcp.OsConfig.Inputs.GuestPoliciesAssignmentGroupLabelArgs
                {
                    Labels =
                    {
                        { "color", "red" },
                        { "env", "test" },
                    },
                },
                new Gcp.OsConfig.Inputs.GuestPoliciesAssignmentGroupLabelArgs
                {
                    Labels =
                    {
                        { "color", "blue" },
                        { "env", "test" },
                    },
                },
            },
        },
        Packages = new[]
        {
            new Gcp.OsConfig.Inputs.GuestPoliciesPackageArgs
            {
                Name = "my-package",
                DesiredState = "INSTALLED",
            },
            new Gcp.OsConfig.Inputs.GuestPoliciesPackageArgs
            {
                Name = "bad-package-1",
                DesiredState = "REMOVED",
            },
            new Gcp.OsConfig.Inputs.GuestPoliciesPackageArgs
            {
                Name = "bad-package-2",
                DesiredState = "REMOVED",
                Manager = "APT",
            },
        },
        PackageRepositories = new[]
        {
            new Gcp.OsConfig.Inputs.GuestPoliciesPackageRepositoryArgs
            {
                Apt = new Gcp.OsConfig.Inputs.GuestPoliciesPackageRepositoryAptArgs
                {
                    Uri = "https://packages.cloud.google.com/apt",
                    ArchiveType = "DEB",
                    Distribution = "cloud-sdk-stretch",
                    Components = new[]
                    {
                        "main",
                    },
                },
            },
            new Gcp.OsConfig.Inputs.GuestPoliciesPackageRepositoryArgs
            {
                Yum = new Gcp.OsConfig.Inputs.GuestPoliciesPackageRepositoryYumArgs
                {
                    Id = "google-cloud-sdk",
                    DisplayName = "Google Cloud SDK",
                    BaseUrl = "https://packages.cloud.google.com/yum/repos/cloud-sdk-el7-x86_64",
                    GpgKeys = new[]
                    {
                        "https://packages.cloud.google.com/yum/doc/yum-key.gpg",
                        "https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg",
                    },
                },
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/osconfig"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := osconfig.NewGuestPolicies(ctx, "guest_policies", &osconfig.GuestPoliciesArgs{
			GuestPolicyId: pulumi.String("guest-policy"),
			Assignment: &osconfig.GuestPoliciesAssignmentArgs{
				GroupLabels: osconfig.GuestPoliciesAssignmentGroupLabelArray{
					&osconfig.GuestPoliciesAssignmentGroupLabelArgs{
						Labels: pulumi.StringMap{
							"color": pulumi.String("red"),
							"env":   pulumi.String("test"),
						},
					},
					&osconfig.GuestPoliciesAssignmentGroupLabelArgs{
						Labels: pulumi.StringMap{
							"color": pulumi.String("blue"),
							"env":   pulumi.String("test"),
						},
					},
				},
			},
			Packages: osconfig.GuestPoliciesPackageArray{
				&osconfig.GuestPoliciesPackageArgs{
					Name:         pulumi.String("my-package"),
					DesiredState: pulumi.String("INSTALLED"),
				},
				&osconfig.GuestPoliciesPackageArgs{
					Name:         pulumi.String("bad-package-1"),
					DesiredState: pulumi.String("REMOVED"),
				},
				&osconfig.GuestPoliciesPackageArgs{
					Name:         pulumi.String("bad-package-2"),
					DesiredState: pulumi.String("REMOVED"),
					Manager:      pulumi.String("APT"),
				},
			},
			PackageRepositories: osconfig.GuestPoliciesPackageRepositoryArray{
				&osconfig.GuestPoliciesPackageRepositoryArgs{
					Apt: &osconfig.GuestPoliciesPackageRepositoryAptArgs{
						Uri:          pulumi.String("https://packages.cloud.google.com/apt"),
						ArchiveType:  pulumi.String("DEB"),
						Distribution: pulumi.String("cloud-sdk-stretch"),
						Components: pulumi.StringArray{
							pulumi.String("main"),
						},
					},
				},
				&osconfig.GuestPoliciesPackageRepositoryArgs{
					Yum: &osconfig.GuestPoliciesPackageRepositoryYumArgs{
						Id:          pulumi.String("google-cloud-sdk"),
						DisplayName: pulumi.String("Google Cloud SDK"),
						BaseUrl:     pulumi.String("https://packages.cloud.google.com/yum/repos/cloud-sdk-el7-x86_64"),
						GpgKeys: pulumi.StringArray{
							pulumi.String("https://packages.cloud.google.com/yum/doc/yum-key.gpg"),
							pulumi.String("https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg"),
						},
					},
				},
			},
		})
		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.osconfig.GuestPolicies;
import com.pulumi.gcp.osconfig.GuestPoliciesArgs;
import com.pulumi.gcp.osconfig.inputs.GuestPoliciesAssignmentArgs;
import com.pulumi.gcp.osconfig.inputs.GuestPoliciesPackageArgs;
import com.pulumi.gcp.osconfig.inputs.GuestPoliciesPackageRepositoryArgs;
import com.pulumi.gcp.osconfig.inputs.GuestPoliciesPackageRepositoryAptArgs;
import com.pulumi.gcp.osconfig.inputs.GuestPoliciesPackageRepositoryYumArgs;
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 guestPolicies = new GuestPolicies("guestPolicies", GuestPoliciesArgs.builder()
            .guestPolicyId("guest-policy")
            .assignment(GuestPoliciesAssignmentArgs.builder()
                .groupLabels(
                    GuestPoliciesAssignmentGroupLabelArgs.builder()
                        .labels(Map.ofEntries(
                            Map.entry("color", "red"),
                            Map.entry("env", "test")
                        ))
                        .build(),
                    GuestPoliciesAssignmentGroupLabelArgs.builder()
                        .labels(Map.ofEntries(
                            Map.entry("color", "blue"),
                            Map.entry("env", "test")
                        ))
                        .build())
                .build())
            .packages(
                GuestPoliciesPackageArgs.builder()
                    .name("my-package")
                    .desiredState("INSTALLED")
                    .build(),
                GuestPoliciesPackageArgs.builder()
                    .name("bad-package-1")
                    .desiredState("REMOVED")
                    .build(),
                GuestPoliciesPackageArgs.builder()
                    .name("bad-package-2")
                    .desiredState("REMOVED")
                    .manager("APT")
                    .build())
            .packageRepositories(
                GuestPoliciesPackageRepositoryArgs.builder()
                    .apt(GuestPoliciesPackageRepositoryAptArgs.builder()
                        .uri("https://packages.cloud.google.com/apt")
                        .archiveType("DEB")
                        .distribution("cloud-sdk-stretch")
                        .components("main")
                        .build())
                    .build(),
                GuestPoliciesPackageRepositoryArgs.builder()
                    .yum(GuestPoliciesPackageRepositoryYumArgs.builder()
                        .id("google-cloud-sdk")
                        .displayName("Google Cloud SDK")
                        .baseUrl("https://packages.cloud.google.com/yum/repos/cloud-sdk-el7-x86_64")
                        .gpgKeys(
                            "https://packages.cloud.google.com/yum/doc/yum-key.gpg",
                            "https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg")
                        .build())
                    .build())
            .build());
    }
}
Content copied to clipboard
resources:
  guestPolicies:
    type: gcp:osconfig:GuestPolicies
    name: guest_policies
    properties:
      guestPolicyId: guest-policy
      assignment:
        groupLabels:
          - labels:
              color: red
              env: test
          - labels:
              color: blue
              env: test
      packages:
        - name: my-package
          desiredState: INSTALLED
        - name: bad-package-1
          desiredState: REMOVED
        - name: bad-package-2
          desiredState: REMOVED
          manager: APT
      packageRepositories:
        - apt:
            uri: https://packages.cloud.google.com/apt
            archiveType: DEB
            distribution: cloud-sdk-stretch
            components:
              - main
        - yum:
            id: google-cloud-sdk
            displayName: Google Cloud SDK
            baseUrl: https://packages.cloud.google.com/yum/repos/cloud-sdk-el7-x86_64
            gpgKeys:
              - https://packages.cloud.google.com/yum/doc/yum-key.gpg
              - https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
Content copied to clipboard

Os Config Guest Policies Recipes

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const guestPolicies = new gcp.osconfig.GuestPolicies("guest_policies", {
    guestPolicyId: "guest-policy",
    assignment: {
        zones: [
            "us-east1-b",
            "us-east1-d",
        ],
    },
    recipes: [{
        name: "guest-policy-recipe",
        desiredState: "INSTALLED",
        artifacts: [{
            id: "guest-policy-artifact-id",
            gcs: {
                bucket: "my-bucket",
                object: "executable.msi",
                generation: 1546030865175603,
            },
        }],
        installSteps: [{
            msiInstallation: {
                artifactId: "guest-policy-artifact-id",
            },
        }],
    }],
});
Content copied to clipboard
import pulumi
import pulumi_gcp as gcp
guest_policies = gcp.osconfig.GuestPolicies("guest_policies",
    guest_policy_id="guest-policy",
    assignment={
        "zones": [
            "us-east1-b",
            "us-east1-d",
        ],
    },
    recipes=[{
        "name": "guest-policy-recipe",
        "desired_state": "INSTALLED",
        "artifacts": [{
            "id": "guest-policy-artifact-id",
            "gcs": {
                "bucket": "my-bucket",
                "object": "executable.msi",
                "generation": 1546030865175603,
            },
        }],
        "install_steps": [{
            "msi_installation": {
                "artifact_id": "guest-policy-artifact-id",
            },
        }],
    }])
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var guestPolicies = new Gcp.OsConfig.GuestPolicies("guest_policies", new()
    {
        GuestPolicyId = "guest-policy",
        Assignment = new Gcp.OsConfig.Inputs.GuestPoliciesAssignmentArgs
        {
            Zones = new[]
            {
                "us-east1-b",
                "us-east1-d",
            },
        },
        Recipes = new[]
        {
            new Gcp.OsConfig.Inputs.GuestPoliciesRecipeArgs
            {
                Name = "guest-policy-recipe",
                DesiredState = "INSTALLED",
                Artifacts = new[]
                {
                    new Gcp.OsConfig.Inputs.GuestPoliciesRecipeArtifactArgs
                    {
                        Id = "guest-policy-artifact-id",
                        Gcs = new Gcp.OsConfig.Inputs.GuestPoliciesRecipeArtifactGcsArgs
                        {
                            Bucket = "my-bucket",
                            Object = "executable.msi",
                            Generation = 1546030865175603,
                        },
                    },
                },
                InstallSteps = new[]
                {
                    new Gcp.OsConfig.Inputs.GuestPoliciesRecipeInstallStepArgs
                    {
                        MsiInstallation = new Gcp.OsConfig.Inputs.GuestPoliciesRecipeInstallStepMsiInstallationArgs
                        {
                            ArtifactId = "guest-policy-artifact-id",
                        },
                    },
                },
            },
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/osconfig"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := osconfig.NewGuestPolicies(ctx, "guest_policies", &osconfig.GuestPoliciesArgs{
			GuestPolicyId: pulumi.String("guest-policy"),
			Assignment: &osconfig.GuestPoliciesAssignmentArgs{
				Zones: pulumi.StringArray{
					pulumi.String("us-east1-b"),
					pulumi.String("us-east1-d"),
				},
			},
			Recipes: osconfig.GuestPoliciesRecipeArray{
				&osconfig.GuestPoliciesRecipeArgs{
					Name:         pulumi.String("guest-policy-recipe"),
					DesiredState: pulumi.String("INSTALLED"),
					Artifacts: osconfig.GuestPoliciesRecipeArtifactArray{
						&osconfig.GuestPoliciesRecipeArtifactArgs{
							Id: pulumi.String("guest-policy-artifact-id"),
							Gcs: &osconfig.GuestPoliciesRecipeArtifactGcsArgs{
								Bucket:     pulumi.String("my-bucket"),
								Object:     pulumi.String("executable.msi"),
								Generation: pulumi.Int(1546030865175603),
							},
						},
					},
					InstallSteps: osconfig.GuestPoliciesRecipeInstallStepArray{
						&osconfig.GuestPoliciesRecipeInstallStepArgs{
							MsiInstallation: &osconfig.GuestPoliciesRecipeInstallStepMsiInstallationArgs{
								ArtifactId: pulumi.String("guest-policy-artifact-id"),
							},
						},
					},
				},
			},
		})
		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.osconfig.GuestPolicies;
import com.pulumi.gcp.osconfig.GuestPoliciesArgs;
import com.pulumi.gcp.osconfig.inputs.GuestPoliciesAssignmentArgs;
import com.pulumi.gcp.osconfig.inputs.GuestPoliciesRecipeArgs;
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 guestPolicies = new GuestPolicies("guestPolicies", GuestPoliciesArgs.builder()
            .guestPolicyId("guest-policy")
            .assignment(GuestPoliciesAssignmentArgs.builder()
                .zones(
                    "us-east1-b",
                    "us-east1-d")
                .build())
            .recipes(GuestPoliciesRecipeArgs.builder()
                .name("guest-policy-recipe")
                .desiredState("INSTALLED")
                .artifacts(GuestPoliciesRecipeArtifactArgs.builder()
                    .id("guest-policy-artifact-id")
                    .gcs(GuestPoliciesRecipeArtifactGcsArgs.builder()
                        .bucket("my-bucket")
                        .object("executable.msi")
                        .generation(1546030865175603)
                        .build())
                    .build())
                .installSteps(GuestPoliciesRecipeInstallStepArgs.builder()
                    .msiInstallation(GuestPoliciesRecipeInstallStepMsiInstallationArgs.builder()
                        .artifactId("guest-policy-artifact-id")
                        .build())
                    .build())
                .build())
            .build());
    }
}
Content copied to clipboard
resources:
  guestPolicies:
    type: gcp:osconfig:GuestPolicies
    name: guest_policies
    properties:
      guestPolicyId: guest-policy
      assignment:
        zones:
          - us-east1-b
          - us-east1-d
      recipes:
        - name: guest-policy-recipe
          desiredState: INSTALLED
          artifacts:
            - id: guest-policy-artifact-id
              gcs:
                bucket: my-bucket
                object: executable.msi
                generation: 1.546030865175603e+15
          installSteps:
            - msiInstallation:
                artifactId: guest-policy-artifact-id
Content copied to clipboard

Import

GuestPolicies can be imported using any of these accepted formats:

  • projects/{{project}}/guestPolicies/{{guest_policy_id}}

  • {{project}}/{{guest_policy_id}}

  • {{guest_policy_id}} When using the pulumi import command, GuestPolicies can be imported using one of the formats above. For example:

$ pulumi import gcp:osconfig/guestPolicies:GuestPolicies default projects/{{project}}/guestPolicies/{{guest_policy_id}}
Content copied to clipboard
$ pulumi import gcp:osconfig/guestPolicies:GuestPolicies default {{project}}/{{guest_policy_id}}
Content copied to clipboard
$ pulumi import gcp:osconfig/guestPolicies:GuestPolicies default {{guest_policy_id}}
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(assignment: Output<GuestPoliciesAssignmentArgs>? = null, description: Output<String>? = null, etag: Output<String>? = null, guestPolicyId: Output<String>? = null, packageRepositories: Output<List<GuestPoliciesPackageRepositoryArgs>>? = null, packages: Output<List<GuestPoliciesPackageArgs>>? = null, project: Output<String>? = null, recipes: Output<List<GuestPoliciesRecipeArgs>>? = null)

Properties

Link copied to clipboard
val assignment: Output<GuestPoliciesAssignmentArgs>? = null

Specifies the VM instances that are assigned to this policy. This allows you to target sets or groups of VM instances by different parameters such as labels, names, OS, or zones. If left empty, all VM instances underneath this policy are targeted. At the same level in the resource hierarchy (that is within a project), the service prevents the creation of multiple policies that conflict with each other. For more information, see how the service handles assignment conflicts. Structure is documented below.

Link copied to clipboard
val description: Output<String>? = null

Description of the guest policy. Length of the description is limited to 1024 characters.

Link copied to clipboard
val etag: Output<String>? = null

The etag for this guest policy. If this is provided on update, it must match the server's etag.

Link copied to clipboard
val guestPolicyId: Output<String>? = null

The logical name of the guest policy in the project with the following restrictions:

Link copied to clipboard
val packageRepositories: Output<List<GuestPoliciesPackageRepositoryArgs>>? = null

A list of package repositories to configure on the VM instance. This is done before any other configs are applied so they can use these repos. Package repositories are only configured if the corresponding package manager(s) are available.

Link copied to clipboard
val packages: Output<List<GuestPoliciesPackageArgs>>? = null

The software packages to be managed by this policy.

Link copied to clipboard
val project: Output<String>? = null
Link copied to clipboard
val recipes: Output<List<GuestPoliciesRecipeArgs>>? = null

A list of Recipes to install on the VM instance.

Functions

Link copied to clipboard
open override fun toJava(): GuestPoliciesArgs