Namespace Pulumi

Classes

Alias

Alias is a description of prior named used for a resource. It can be processed in the context of a resource creation to determine what the full aliased URN would be.

Use Urn in the case where a prior URN is known and can just be specified in full. Otherwise, provide some subset of the other properties in this type to generate an appropriate urn from the pre-existing values of the Resource with certain parts overridden.

The presence of a property indicates if its value should be used. If absent (i.e. null), then the value is not used.

Note: because of the above, there needs to be special handling to indicate that the previous Parent of a Resource was null. Specifically, pass in:

Aliases = { new Alias { NoParent = true } }

Archive

An Archive represents a collection of named assets.

Asset

Asset represents a single blob of text or data that is managed as a first class entity.

AssetArchive

An AssetArchive is an archive created from an in-memory collection of named assets or other archives.

AssetOrArchive

Base class of Assets and Archives.

CallArgs

Base type for all call argument classes.

CallOptions

Options to help control the behavior of Call<T>(string, CallArgs, Resource, CallOptions, bool).

ComponentResource

A Resource that aggregates one or more other child resources into a higher level abstraction. The component resource itself is a resource, but does not require custom CRUD operations for provisioning.

ComponentResourceOptions

A bag of optional settings that control a ComponentResource's behavior.

Config

Config is a bag of related configuration state. Each bag contains any number of configuration variables, indexed by simple keys, and each has a name that uniquely identifies it; two bags with different names do not share values for variables that otherwise share the same key. For example, a bag whose name is pulumi:foo, with keys a, b, and c, is entirely separate from a bag whose name is pulumi:bar with the same simple key names. Each key has a fully qualified names, such as pulumi:foo:a, ..., and pulumi:bar:a, respectively.

CustomResource

CustomResource is a resource whose create, read, update, and delete (CRUD) operations are managed by performing external operations on some physical entity. The engine understands how to diff and perform partial updates of them, and these CRUD operations are implemented in a dynamically loaded plugin for the defining package.

CustomResourceOptions

CustomResourceOptions is a bag of optional settings that control a CustomResource's behavior.

CustomTimeouts

Optional timeouts to supply in CustomTimeouts.

Deployment

Deployment is the entry-point to a Pulumi application. .NET applications should perform all startup logic they need in their Main method and then end with:

static Task<int> Main(string[] args) { // program initialization code ... 

return Deployment.Run(async () =>
{
    // Code that creates resources.
});

}

Importantly: Cloud resources cannot be created outside of the lambda passed to any of the RunAsync(Action) overloads. Because cloud Resource construction is inherently asynchronous, the result of this function is a Task<TResult> which should then be returned or awaited. This will ensure that any problems that are encountered during the running of the program are properly reported. Failure to do this may lead to the program ending early before all resources are properly registered.

DeploymentInstance

Metadata of the deployment that is currently running. Accessible via Instance.

DictionaryInvokeArgs

A special type of InvokeArgs with resource inputs represented as a loosely-typed dictionary of objects. Normally, DictionaryInvokeArgs should not be used by resource providers since it's too low-level and provides low safety. Its target scenario are resources with a very dynamic shape of inputs. The input dictionary may only contain objects that are serializable by Pulumi, i.e only the following types (or pulumi.Output of those types) are allowed:

DictionaryResourceArgs

A special type of ResourceArgs with resource inputs represented as a loosely-typed dictionary of objects. Normally, DictionaryResourceArgs should not be used by resource providers since it's too low-level and provides low safety. Its target scenario are resources with a very dynamic shape of inputs. The input dictionary may only contain objects that are serializable by Pulumi, i.e only the following types (or pulumi.Output of those types) are allowed:

EnumTypeAttribute

Attribute used by a Pulumi Cloud Provider Package to mark enum types.

Requirements for a struct-based enum to be (de)serialized are as follows. It must:

  • Be a value type (struct) decoratted with EnumTypeAttribute.
  • Have a constructor that takes a single parameter of the underlying type. The constructor can be private.
  • Have an explicit conversion operator that converts the enum type to the underlying type.
  • Have an underlying type of String or Double.
  • Implementing IEquatable, adding ==/=! operators and overriding ToString isn't required, but is recommended and is what our codegen does.

FileArchive

A FileArchive is a file-based archive, or a collection of file-based assets. This can be a raw directory or a single archive file in one of the supported formats(.tar, .tar.gz, or.zip).

FileAsset

FileAsset is a kind of asset produced from a given path to a file on the local filesystem.

Input<T>

Input<T> is a property input for a Resource. It may be a promptly available T, or the output from a existing Resource.

InputArgs

Base type for all input argument classes.

InputAttribute

Attribute used by a Pulumi Cloud Provider Package to mark Resource input fields and properties.

Note: for simple inputs (i.e. Input<T> this should just be placed on the property itself. i.e. [Input] Input<string> Acl.

For collection inputs (i.e. InputList<T> this should be placed on the backing field for the property. i.e.

    [Input] private InputList<string> _acls;
    public InputList<string> Acls
    {
        get => _acls ?? (_acls = new InputList<string>());
        set => _acls = value;
    }

InputExtensions

InputJson

Represents an Input<T> value that wraps a JsonElement.

InputList<T>

A list of values that can be passed in as the arguments to a Resource. The individual values are themselves Input<T>s. i.e. the individual values can be concrete values or Output<T>s.

InputList<T> differs from a normal IList<T> in that it is itself an Input<T>. For example, a Resource that accepts an InputList<T> will accept not just a list but an Output<T> of a list. This is important for cases where the Output<T> list from some Resource needs to be passed into another Resource. Or for cases where creating the list invariably produces an Output<T> because its resultant value is dependent on other Output<T>s.

This benefit of InputList<T> is also a limitation. Because it represents a list of values that may eventually be created, there is no way to simply iterate over, or access the elements of the list synchronously.

InputList<T> is designed to be easily used in object and collection initializers. For example, a resource that accepts a list of inputs can be written in either of these forms: 

    new SomeResource("name", new SomeResourceArgs {
        ListProperty = { Value1, Value2, Value3 },
    });

or 
    new SomeResource("name", new SomeResourceArgs {
        ListProperty = new [] { Value1, Value2, Value3 },
    });

InputListExtensions

InputMap<V>

A mapping of strings to values that can be passed in as the arguments to a Resource. The individual values are themselves Input<T>s. i.e. the individual values can be concrete values or Output<T>s.

InputMap<V> differs from a normal IDictionary<TKey, TValue> in that it is itself an Input<T>. For example, a Resource that accepts an InputMap<V> will accept not just a dictionary but an Output<T> of a dictionary as well. This is important for cases where the Output<T> map from some Resource needs to be passed into another Resource. Or for cases where creating the map invariably produces an Output<T> because its resultant value is dependent on other Output<T>s.

This benefit of InputMap<V> is also a limitation. Because it represents a list of values that may eventually be created, there is no way to simply iterate over, or access the elements of the map synchronously.

InputMap<V> is designed to be easily used in object and collection initializers. For example, a resource that accepts a map of values can be written easily in this form: 

    new SomeResource("name", new SomeResourceArgs {
        MapProperty = {
            { Key1, Value1 },
            { Key2, Value2 },
            { Key3, Value3 },
        },
    });

InputMapExtensions

InputUnion<T0, T1>

Represents an Input<T> value that can be one of two different types. For example, it might potentially be an int some of the time or a string in other cases.

InvokeArgs

Base type for all invoke argument classes.

InvokeOptions

Options to help control the behavior of InvokeAsync<T>(string, InvokeArgs, InvokeOptions).

Log

Logging functions that can be called from a .NET application that will be logged to the Pulumi log stream. These events will be printed in the terminal while the Pulumi app runs, and will be available from the Web console afterwards.

LogException

Special exception we throw if we had a problem actually logging a message to the engine error rpc endpoint. In this case, we have no choice but to tear ourselves down reporting whatever we can to the console instead.

Output

Useful static utility methods for both creating and working with Output<T>s.

Output<T>

Output<T>s are a key part of how Pulumi tracks dependencies between Resources. Because the values of outputs are not available until resources are created, these are represented using the special Output<T>s type, which internally represents two things: an eventually available value of the output and the dependency on the source(s) of the output value. In fact, Output<T>s is quite similar to Task<TResult>. Additionally, they carry along dependency information.

The output properties of all resource objects in Pulumi have type Output<T>.

OutputAttribute

Attribute used by a mark Resource output properties. Use this attribute in your Pulumi programs to mark outputs of ComponentResource and Stack resources.

OutputConstructorAttribute

Attribute used by a Pulumi Cloud Provider Package to marks the constructor for a complex property type so that it can be instantiated by the Pulumi runtime.

The constructor should contain parameters that map to the resultant Fields returned by the engine.

OutputExtensions

Extension methods for Output<T>.

OutputTypeAttribute

Attribute used by a Pulumi Cloud Provider Package to mark complex types used for a Resource output property. A complex type must have a single constructor in it marked with the OutputConstructorAttribute attribute.

ProviderResource

ProviderResource is a Resource that implements CRUD operations for other custom resources. These resources are managed similarly to other resources, including the usual diffing and update semantics.

RemoteArchive

A RemoteArchive is a file-based archive fetched from a remote location. The URI's scheme dictates the protocol for fetching the archive's contents: file:// is a local file (just like a FileArchive), http:// and https:// specify HTTP and HTTPS, respectively, and specific providers may recognize custom schemes.

RemoteAsset

RemoteAsset is a kind of asset produced from a given URI string. The URI's scheme dictates the protocol for fetching contents: file:// specifies a local file, http:// and https:// specify HTTP and HTTPS, respectively. Note that specific providers may recognize alternative schemes; this is merely the base-most set that all providers support.

Resource

Resource represents a class whose CRUD operations are implemented by a provider plugin.

ResourceArgs

Base type for all resource argument classes.

ResourceException

ResourceException can be used for terminating a program abruptly, specifically associating the problem with a Resource.Depending on the nature of the problem, clients can choose whether or not a call stack should be returned as well. This should be very rare, and would only indicate no usefulness of presenting that stack to the user.

ResourceOptions

ResourceOptions is a bag of optional settings that control a resource's behavior.

ResourceTypeAttribute

Stack

Stack is the root resource for a Pulumi stack. Derive from this class to create your stack definitions.

StackOptions

StackOptions is a bag of optional settings that control a stack's behavior.

StackReference

Manages a reference to a Pulumi stack and provides access to the referenced stack's outputs.

StackReferenceArgs

The set of arguments for constructing a StackReference resource.

StackReferenceOutputDetails

Holds a StackReference's output value. At most one of Value and SecretValue will be set.

StringAsset

StringAsset is a kind of asset produced from an in-memory UTF8-encoded string.

Urn

An automatically generated logical URN, used to stably identify resources. These are created automatically by Pulumi to identify resources. They cannot be manually constructed.

Structs

ResourceTransformationArgs

ResourceTransformationResult

Union<T0, T1>

Represents a Tagged Union.

This is used to hold a value that could take on several different, but fixed, types. Only one of the types can be in use at any one time. It can be thought of as a type that has several "cases," each of which should be handled correctly when that type is manipulated.

For example, a Resource property that could either store a int or a string can be represented as Output<int, string>. The Input<T> version of this is InputUnion<T0, T1>.

Delegates

ResourceTransformation

ResourceTransformation is the callback signature for ResourceTransformations. A transformation is passed the same set of inputs provided to the Resource constructor, and can optionally return back alternate values for the properties and/or options prior to the resource actually being created. The effect will be as though those properties and/or options were passed in place of the original call to the Resource constructor. If the transformation returns null, this indicates that the resource will not be transformed.