1. Docs
  2. Concepts
  3. Inputs & outputs

Inputs & outputs

    Inputs

    All resources in Pulumi accept values that describe the way the resource behaves. We call these values inputs.

    const myId = new random.RandomId("mine", {
        byteLength: 8, // byteLength is an input
    });
    
    const myId = new random.RandomId("mine", {
        byteLength: 8, // byteLength is an input
    });
    
    my_id = random.RandomId("mine",
        byte_length=8 # byte_length is an input
    )
    
    
    myId, err := random.NewRandomId(ctx, "mine", &random.RandomIdArgs{
    	ByteLength: pulumi.Int(8), // ByteLength is an input
    })
    if err != nil {
    	return err
    }
    
    var myId = new Random.RandomId("mine", new()
    {
        ByteLength = 8, // ByteLength is an input
    });
    
    var myId = new RandomId("mine", RandomIdArgs.builder()
        .byteLength(8) // byteLength is an input
        .build());
    
    resources:
      myId:
        type: random:randomId
        properties:
          byteLength: 8 # byteLength is an input
    

    Inputs are generally representations of the parameters to the underlying API call of any resource that Pulumi is managing. The simplest way to create a resource with its required inputs is to use a plain value.

    const key = new tls.PrivateKey("my-private-key", {
        algorithm: "ECDSA", // ECDSA is a plain value
    });
    
    const key = new tls.PrivateKey("my-private-key", {
        algorithm: "ECDSA", // ECDSA is a plain value
    });
    
    key = tls.PrivateKey("my-private-key",
      algorithm="ECDSA", # ECDSA is a plain value
    )
    
    
    key, err := tls.NewPrivateKey(ctx, "my-private-key", &tls.PrivateKeyArgs{
    	Algorithm:  pulumi.String("ECDSA"), // ECDSA is a plain value
    })
    if err != nil {
    	return err
    }
    
    var key = new PrivateKey("my-private-key", new PrivateKeyArgs{
        Algorithm = "ECDSA", // ECDSA is a plain value
    });
    
    var key = new PrivateKey("my-private-key", PrivateKeyArgs.builder()
        .algorithm("ECDSA") // ECDSA is a plain value
        .build()
    )
    
    resources:
      key:
        type: tls:PrivateKey
        properties:
          algorithm: "ECDSA" # ECDSA is a plain value
    
    Plain value in this document is used to describe a standard string, boolean, integer or other typed value or data structure in your language of choice. Plain value is a way of differentiating these language specific values from Pulumi’s asynchronous values.

    However, in most Pulumi programs, the inputs to a resource will reference values from another resource:

    let password = new random.RandomPassword("password", {
        length: 16,
        special: true,
        overrideSpecial: "!#$%&*()-_=+[]{}<>:?",
    });
    let example = new aws.rds.Instance("example", {
        instanceClass: "db.t3.micro",
        allocatedStorage: 64,
        engine: "mysql",
        username: "someone",
        password: password.result, // We pass the output from password as an input
    });
    
    const password = new random.RandomPassword("password", {
        length: 16,
        special: true,
        overrideSpecial: "!#$%&*()-_=+[]{}<>:?",
    });
    const example = new aws.rds.Instance("example", {
        instanceClass: "db.t3.micro",
        allocatedStorage: 64,
        engine: "mysql",
        username: "someone",
        password: password.result, // We pass the output from password as an input
    });
    
    password = random.RandomPassword(
        "password",
        length=16,
        special=True,
        override_special="!#$%&*()-_=+[]{}<>:?"
    )
    example = aws.rds.Instance(
        "example",
        instance_class="db.t3.micro",
        allocated_storage=64,
        engine="mysql",
        username="someone",
        password=password.result, # We pass the output from password as an input
    )
    
    password, err := random.NewRandomPassword(ctx, "password", &random.RandomPasswordArgs{
    	Length:          pulumi.Int(16),
    	Special:         pulumi.Bool(true),
    	OverrideSpecial: pulumi.String("!#$%&*()-_=+[]{}<>:?"),
    })
    if err != nil {
    	return err
    }
    _, err = rds.NewInstance(ctx, "example", &rds.InstanceArgs{
    	InstanceClass:    pulumi.String("db.t3.micro"),
    	AllocatedStorage: pulumi.Int(64),
    	Engine:           pulumi.String("mysql"),
    	Username:         pulumi.String("someone"),
    	Password:         password.Result, // We pass the output from password as an input
    })
    if err != nil {
    	return err
    }
    
    var password = new Random.RandomPassword("password", new()
    {
        Length = 16,
        Special = true,
        OverrideSpecial = "!#$%&*()-_=+[]{}<>:?",
    });
    
    var example = new Aws.Rds.Instance("example", new()
    {
        InstanceClass = "db.t3.micro",
        AllocatedStorage = 64,
        Engine = "mysql",
        Username = "someone",
        Password = password.Result, // We pass the output from password as an input
    });
    
    var password = new RandomPassword("password", RandomPasswordArgs.builder()
        .length(16)
        .special(true)
        .overrideSpecial("!#$%&*()-_=+[]{}<>:?")
        .build());
    
    var example = new Instance("example", InstanceArgs.builder()
        .instanceClass("db.t3.micro")
        .allocatedStorage(64)
        .engine("mysql")
        .username("someone")
        .password(password.result()) // We pass the output from password as an input
        .build());
    

    In this case, Pulumi is taking the output from one resource and using it as the input to another resource.

    Outputs

    All resources created by Pulumi will have properties which are returned from the cloud provider API. These values are called outputs.

    Outputs are values of type Output Output<T> Output[T] Output Output<T> , which behave very much like promises or monads. Simply put, outputs are a way of representing values that are not initially known but will become available once the infrastructure resource has completed provisioning, and this happens asynchronously. This is because the provisioning of resources is an asynchronous operation. It takes time for a cloud provider to complete the provisioning process, and Pulumi optimizes the process by executing operations in parallel rather than sequentially.

    Because outputs are asynchronous, their actual plain values are not immediately available. If you need to access an output’s plain value, you can do so using one of the following options:

    • Apply: a callback that receives the plain value and computes a new output, generally used for accessing single values
    • Lifting: directly read the value of an output, generally used for accessing nested values
    • Interpolation: concatenate string outputs with other strings

    Tracking dependencies

    Outputs are also how Pulumi tracks dependencies between resources. When an output from one resource has been returned from the cloud provider API, Pulumi can link the two resources together and pass it as the input to another resource.

    Pulumi automatically captures dependencies when you pass an output from one resource as an input to another resource. Capturing these dependencies ensures that the physical infrastructure resources are not created or updated until all their dependencies are available and up-to-date.

      Pulumi AI - What cloud infrastructure would you like to build? Generate Program