FolderSinkArgs

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
const log_bucket = new gcp.storage.Bucket("log-bucket", {
    name: "folder-logging-bucket",
    location: "US",
});
const my_folder = new gcp.organizations.Folder("my-folder", {
    displayName: "My folder",
    parent: "organizations/123456",
});
const my_sink = new gcp.logging.FolderSink("my-sink", {
    name: "my-sink",
    description: "some explanation on what this is",
    folder: my_folder.name,
    destination: pulumi.interpolate`storage.googleapis.com/${log_bucket.name}`,
    filter: "resource.type = gce_instance AND severity >= WARNING",
});
const log_writer = new gcp.projects.IAMBinding("log-writer", {
    project: "your-project-id",
    role: "roles/storage.objectCreator",
    members: [my_sink.writerIdentity],
});

import pulumi
import pulumi_gcp as gcp
log_bucket = gcp.storage.Bucket("log-bucket",
    name="folder-logging-bucket",
    location="US")
my_folder = gcp.organizations.Folder("my-folder",
    display_name="My folder",
    parent="organizations/123456")
my_sink = gcp.logging.FolderSink("my-sink",
    name="my-sink",
    description="some explanation on what this is",
    folder=my_folder.name,
    destination=log_bucket.name.apply(lambda name: f"storage.googleapis.com/{name}"),
    filter="resource.type = gce_instance AND severity >= WARNING")
log_writer = gcp.projects.IAMBinding("log-writer",
    project="your-project-id",
    role="roles/storage.objectCreator",
    members=[my_sink.writer_identity])

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
return await Deployment.RunAsync(() =>
{
    var log_bucket = new Gcp.Storage.Bucket("log-bucket", new()
    {
        Name = "folder-logging-bucket",
        Location = "US",
    });
    var my_folder = new Gcp.Organizations.Folder("my-folder", new()
    {
        DisplayName = "My folder",
        Parent = "organizations/123456",
    });
    var my_sink = new Gcp.Logging.FolderSink("my-sink", new()
    {
        Name = "my-sink",
        Description = "some explanation on what this is",
        Folder = my_folder.Name,
        Destination = log_bucket.Name.Apply(name => $"storage.googleapis.com/{name}"),
        Filter = "resource.type = gce_instance AND severity >= WARNING",
    });
    var log_writer = new Gcp.Projects.IAMBinding("log-writer", new()
    {
        Project = "your-project-id",
        Role = "roles/storage.objectCreator",
        Members = new[]
        {
            my_sink.WriterIdentity,
        },
    });
});

package main
import (
	"fmt"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/logging"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/projects"
	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/storage"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := storage.NewBucket(ctx, "log-bucket", &storage.BucketArgs{
			Name:     pulumi.String("folder-logging-bucket"),
			Location: pulumi.String("US"),
		})
		if err != nil {
			return err
		}
		_, err = organizations.NewFolder(ctx, "my-folder", &organizations.FolderArgs{
			DisplayName: pulumi.String("My folder"),
			Parent:      pulumi.String("organizations/123456"),
		})
		if err != nil {
			return err
		}
		_, err = logging.NewFolderSink(ctx, "my-sink", &logging.FolderSinkArgs{
			Name:        pulumi.String("my-sink"),
			Description: pulumi.String("some explanation on what this is"),
			Folder:      my_folder.Name,
			Destination: log_bucket.Name.ApplyT(func(name string) (string, error) {
				return fmt.Sprintf("storage.googleapis.com/%v", name), nil
			}).(pulumi.StringOutput),
			Filter: pulumi.String("resource.type = gce_instance AND severity >= WARNING"),
		})
		if err != nil {
			return err
		}
		_, err = projects.NewIAMBinding(ctx, "log-writer", &projects.IAMBindingArgs{
			Project: pulumi.String("your-project-id"),
			Role:    pulumi.String("roles/storage.objectCreator"),
			Members: pulumi.StringArray{
				my_sink.WriterIdentity,
			},
		})
		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.storage.Bucket;
import com.pulumi.gcp.storage.BucketArgs;
import com.pulumi.gcp.organizations.Folder;
import com.pulumi.gcp.organizations.FolderArgs;
import com.pulumi.gcp.logging.FolderSink;
import com.pulumi.gcp.logging.FolderSinkArgs;
import com.pulumi.gcp.projects.IAMBinding;
import com.pulumi.gcp.projects.IAMBindingArgs;
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 log_bucket = new Bucket("log-bucket", BucketArgs.builder()
            .name("folder-logging-bucket")
            .location("US")
            .build());
        var my_folder = new Folder("my-folder", FolderArgs.builder()
            .displayName("My folder")
            .parent("organizations/123456")
            .build());
        var my_sink = new FolderSink("my-sink", FolderSinkArgs.builder()
            .name("my-sink")
            .description("some explanation on what this is")
            .folder(my_folder.name())
            .destination(log_bucket.name().applyValue(name -> String.format("storage.googleapis.com/%s", name)))
            .filter("resource.type = gce_instance AND severity >= WARNING")
            .build());
        var log_writer = new IAMBinding("log-writer", IAMBindingArgs.builder()
            .project("your-project-id")
            .role("roles/storage.objectCreator")
            .members(my_sink.writerIdentity())
            .build());
    }
}

resources:
  my-sink:
    type: gcp:logging:FolderSink
    properties:
      name: my-sink
      description: some explanation on what this is
      folder: ${["my-folder"].name}
      destination: storage.googleapis.com/${["log-bucket"].name}
      filter: resource.type = gce_instance AND severity >= WARNING
  log-bucket:
    type: gcp:storage:Bucket
    properties:
      name: folder-logging-bucket
      location: US
  log-writer:
    type: gcp:projects:IAMBinding
    properties:
      project: your-project-id
      role: roles/storage.objectCreator
      members:
        - ${["my-sink"].writerIdentity}
  my-folder:
    type: gcp:organizations:Folder
    properties:
      displayName: My folder
      parent: organizations/123456

$ pulumi import gcp:logging/folderSink:FolderSink default folders/{{folder_id}}/sinks/{{name}}